public void Visit(ValueNode node, INode parentNode) { //TODO support Label text as element XmlName propertyName; if (!TryGetPropertyName(node, parentNode, out propertyName)) { if (!IsCollectionItem(node, parentNode)) return; string contentProperty; if (!Context.Variables.ContainsKey((IElementNode)parentNode)) return; var parentVar = Context.Variables[(IElementNode)parentNode]; if ((contentProperty = GetContentProperty(parentVar.VariableType)) != null) propertyName = new XmlName(((IElementNode)parentNode).NamespaceURI, contentProperty); else return; } if (skips.Contains(propertyName)) return; if (node.SkipPrefix((node.NamespaceResolver ?? parentNode.NamespaceResolver)?.LookupPrefix(propertyName.NamespaceURI))) return; if (propertyName.NamespaceURI == "http://schemas.openxmlformats.org/markup-compatibility/2006" && propertyName.LocalName == "Ignorable") { (parentNode.IgnorablePrefixes ?? (parentNode.IgnorablePrefixes = new List<string>())).AddRange( (node.Value as string).Split(',')); return; } SetPropertyValue(Context.Variables[(IElementNode)parentNode], propertyName, node, Context, node); }
internal static bool IsNullOrEmpty(XmlName xmlName) { if (xmlName != null) { return xmlName.IsEmpty; } return true; }
public static void SetXsiType(this IXmlNode node, XmlName xsiType) { if (xsiType.NamespaceUri != null) { var prefix = node.Namespaces.GetAttributePrefix(node, xsiType.NamespaceUri); xsiType = xsiType.WithNamespaceUri(prefix); } node.SetAttribute(Xsi.Type, xsiType.ToString()); }
internal static XmlQualifiedName GetContractName(Type contractType, string name, string ns) { XmlName name2 = new XmlName(name ?? TypeName(contractType)); if (ns == null) { ns = "http://tempuri.org/"; } return new XmlQualifiedName(name2.EncodedName, ns); }
public XmlIncludedType(XmlName xsiType, Type clrType) { if (xsiType.LocalName == null) throw Error.ArgumentNull("xsiType.LocalName"); if (clrType == null) throw Error.ArgumentNull("clrType"); this.xsiType = xsiType; this.clrType = clrType; }
public XmlKnownType(XmlName name, XmlName xsiType, Type clrType) { if (name.LocalName == null) throw Error.ArgumentNull("name.LocalName"); if (clrType == null) throw Error.ArgumentNull("clrType"); this.name = name; this.xsiType = xsiType; this.clrType = clrType; }
private bool ConsumeNode() { var result = true; var path = Node.Path; if (path != null) result = ConsumeFirstStep(path); else Name = Node.Name; Node = Node.Parent; return result; }
public MessagePartDescription(string name, string ns) { if (name == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("name"); } this.name = new XmlName(name, true); if (!string.IsNullOrEmpty(ns)) { NamingHelper.CheckUriParameter(ns, "ns"); } this.ns = ns; }
protected XmlAccessor(Type clrType, IXmlContext context) { if (clrType == null) throw Error.ArgumentNull("clrType"); if (context == null) throw Error.ArgumentNull("context"); clrType = clrType.NonNullable(); this.clrType = clrType; this.xsiType = context.GetDefaultXsiType(clrType); this.serializer = XmlTypeSerializer.For(clrType); this.context = context; }
public XmlName GetNameForPrefix( string prefix ) { prefix = table.NameTable.Add( prefix ); XmlName n = firstName; for (; n != null; n = n.next) { if ((object)n.Prefix == (object)prefix) return n; } n = new XmlName( this, prefix ); n.next = firstName; firstName = n; return n; }
// Methods internal MessagePartDescription(MessagePartDescription other) { this.name = other.name; this.ns = other.ns; this.index = other.index; this.type = other.type; this.serializationPosition = other.serializationPosition; this.hasProtectionLevel = other.hasProtectionLevel; this.protectionLevel = other.protectionLevel; this.memberInfo = other.memberInfo; this.multiple = other.multiple; this.additionalAttributesProvider = other.additionalAttributesProvider; this.baseType = other.baseType; this.uniquePartName = other.uniquePartName; }
public void Visit(ValueNode node, INode parentNode) { var parentElement = parentNode as IElementNode; var value = Values[node]; var source = Values[parentNode]; XmlName propertyName; if (TryGetPropertyName(node, parentNode, out propertyName)) { if (Skips.Contains(propertyName)) return; if (parentElement.SkipProperties.Contains(propertyName)) return; if (parentElement.SkipPrefix(node.NamespaceResolver.LookupPrefix(propertyName.NamespaceURI))) return; if (propertyName.NamespaceURI == "http://schemas.openxmlformats.org/markup-compatibility/2006" && propertyName.LocalName == "Ignorable") { (parentNode.IgnorablePrefixes ?? (parentNode.IgnorablePrefixes = new List<string>())).AddRange( (value as string).Split(',')); return; } SetPropertyValue(source, propertyName, value, Context.RootElement, node, Context, node); } else if (IsCollectionItem(node, parentNode) && parentNode is IElementNode) { // Collection element, implicit content, or implicit collection element. var contentProperty = GetContentPropertyName(Context.Types[parentElement].GetTypeInfo()); if (contentProperty != null) { var name = new XmlName(((ElementNode)parentNode).NamespaceURI, contentProperty); if (Skips.Contains(name)) return; if (parentElement.SkipProperties.Contains(propertyName)) return; SetPropertyValue(source, name, value, Context.RootElement, node, Context, node); } } }
// Methods public OperationDescription(string name, ContractDescription declaringContract) { this.validateRpcWrapperName = true; if (name == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("name"); } if (name.Length == 0) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("name", SR.GetString("SFxOperationDescriptionNameCannotBeEmpty"))); } this.name = new XmlName(name, true); if (declaringContract == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("declaringContract"); } this.declaringContract = declaringContract; this.isInitiating = true; this.isTerminating = false; this.faults = new FaultDescriptionCollection(); this.messages = new MessageDescriptionCollection(); this.behaviors = new KeyedByTypeCollection<IOperationBehavior>(); this.knownTypes = new Collection<Type>(); }
public static void SetPropertyValue(object xamlelement, XmlName propertyName, object value, object rootElement, INode node, HydratationContext context, IXmlLineInfo lineInfo) { var elementType = xamlelement.GetType(); var localname = propertyName.LocalName; var serviceProvider = new XamlServiceProvider(node, context); //If it's an attached BP, update elementType and propertyName var attached = GetRealNameAndType(ref elementType, propertyName.NamespaceURI, ref localname, context, lineInfo); //If the target is an event, connect var eventInfo = elementType.GetRuntimeEvent(localname); if (eventInfo != null && value is string) { var methodInfo = rootElement.GetType().GetRuntimeMethods().FirstOrDefault(mi => mi.Name == (string)value); if (methodInfo == null) { var xpe = new XamlParseException (string.Format ("No method {0} found on type {1}", value, rootElement.GetType ()), lineInfo); if (context.DoNotThrowOnExceptions) { System.Diagnostics.Debug.WriteLine (xpe.Message); return; } else throw xpe; } try { eventInfo.AddEventHandler(xamlelement, methodInfo.CreateDelegate(eventInfo.EventHandlerType, rootElement)); } catch (ArgumentException) { var xpe = new XamlParseException (string.Format ("Method {0} does not have the correct signature", value), lineInfo); if (context.DoNotThrowOnExceptions) System.Diagnostics.Debug.WriteLine (xpe.Message); else throw xpe; } return; } var property = GetBindableProperty(elementType, localname, lineInfo, false); //If Value is DynamicResource and it's a BP, SetDynamicResource if (value is DynamicResource && property != null) { if (!(xamlelement.GetType()).GetTypeInfo().IsSubclassOf(typeof (BindableObject))) throw new XamlParseException(string.Format("{0} is not a BindableObject", xamlelement.GetType().Name), lineInfo); ((BindableObject)xamlelement).SetDynamicResource(property, ((DynamicResource)value).Key); return; } //If value is BindingBase, and target is a BindableProperty, SetBinding if (value is BindingBase && property != null) { if (!(xamlelement.GetType()).GetTypeInfo().IsSubclassOf(typeof (BindableObject))) throw new XamlParseException(string.Format("{0} is not a BindableObject", xamlelement.GetType().Name), lineInfo); ((BindableObject)xamlelement).SetBinding(property, value as BindingBase); return; } //If it's a BindableProberty, SetValue if (property != null) { if (!(xamlelement.GetType()).GetTypeInfo().IsSubclassOf(typeof (BindableObject))) throw new XamlParseException(string.Format("{0} is not a BindableObject", xamlelement.GetType().Name), lineInfo); Func<MemberInfo> minforetriever; if (attached) minforetriever = () => elementType.GetRuntimeMethod("Get" + localname, new[] { typeof (BindableObject) }); else minforetriever = () => elementType.GetRuntimeProperty(localname); var convertedValue = value.ConvertTo(property.ReturnType, minforetriever, serviceProvider); //SetValue doesn't throw on mismatching type, so check before to get a chance to try the property setting or the collection adding var nullable = property.ReturnTypeInfo.IsGenericType && property.ReturnTypeInfo.GetGenericTypeDefinition() == typeof (Nullable<>); if ((convertedValue == null && (!property.ReturnTypeInfo.IsValueType || nullable)) || (property.ReturnType.IsInstanceOfType(convertedValue))) { ((BindableObject)xamlelement).SetValue(property, convertedValue); return; } } var exception = new XamlParseException( String.Format("No Property of name {0} found", propertyName.LocalName), lineInfo); //If we can assign that value to a normal property, let's do it var propertyInfo = elementType.GetRuntimeProperties().FirstOrDefault(p => p.Name == localname); MethodInfo setter; if (propertyInfo != null && propertyInfo.CanWrite && (setter = propertyInfo.SetMethod) != null) { object convertedValue = value.ConvertTo(propertyInfo.PropertyType, () => propertyInfo, serviceProvider); if (convertedValue == null || propertyInfo.PropertyType.IsInstanceOfType(convertedValue)) { try { setter.Invoke(xamlelement, new[] { convertedValue }); return; } catch (ArgumentException) { } } else { exception = new XamlParseException( String.Format("Cannot assign property \"{0}\": type mismatch between \"{1}\" and \"{2}\"", propertyName.LocalName, value.GetType(), propertyInfo.PropertyType), lineInfo); } } //If it's an already initialized property, add to it MethodInfo getter; if (propertyInfo != null && propertyInfo.CanRead && (getter = propertyInfo.GetMethod) != null) { IEnumerable collection; MethodInfo addMethod; if ((collection = getter.Invoke(xamlelement, new object[] { }) as IEnumerable) != null && (addMethod = collection.GetType().GetRuntimeMethods().First(mi => mi.Name == "Add" && mi.GetParameters().Length == 1)) != null) { addMethod.Invoke(collection, new[] { value.ConvertTo(propertyInfo.PropertyType, (Func<TypeConverter>)null, serviceProvider) }); return; } } if (context.DoNotThrowOnExceptions) System.Diagnostics.Debug.WriteLine (exception.Message); else throw exception; }
public static void WriteStartAttribute(this XmlWriter writer, XmlName name) { writer.WriteStartAttribute(null, name.LocalName, name.NamespaceUri); }
public static bool TryGetPropertyName(INode node, INode parentNode, out XmlName name) { name = default(XmlName); var parentElement = parentNode as IElementNode; if (parentElement == null) return false; foreach (var kvp in parentElement.Properties) { if (kvp.Value != node) continue; name = kvp.Key; return true; } return false; }
internal void SetNameAndElement(XmlName name) { this.elementName = this.name = name; }
MessageDescription CreateParameterMessageDescription(ContractDescription contract, ParameterInfo[] parameters, Type returnType, ICustomAttributeProvider returnCustomAttributes, XmlName returnValueName, string methodName, string ns, string action, MessageDirection direction, bool allowReferences) { MessageDescription messageDescription = new MessageDescription(action, direction); messageDescription.Body.WrapperNamespace = ns; for (int index = 0; index < parameters.Length; index++) { ParameterInfo parameter = parameters[index]; Type parameterType = TypeLoader.GetParameterType(parameter); if (!ComPlusTypeValidator.IsValidParameter(parameterType, parameter, allowReferences)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ListenerInitFailed(SR.GetString(SR.InvalidWebServiceParameter, parameter.Name, parameterType.Name, methodName, contract.Name))); } MessagePartDescription messagePart = CreateMessagePartDescription(parameterType, new XmlName(parameter.Name), ns, index); messageDescription.Body.Parts.Add(messagePart); } XmlName xmlName = new XmlName(methodName); if (returnType == null) { messageDescription.Body.WrapperName = xmlName.EncodedName; } else { messageDescription.Body.WrapperName = TypeLoader.GetBodyWrapperResponseName(xmlName).EncodedName; if (!ComPlusTypeValidator.IsValidParameter(returnType, returnCustomAttributes, allowReferences)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ListenerInitFailed(SR.GetString(SR.InvalidWebServiceReturnValue, returnType.Name, methodName, contract.Name))); } MessagePartDescription messagePart = CreateMessagePartDescription(returnType, returnValueName, ns, 0); messageDescription.Body.ReturnValue = messagePart; } return(messageDescription); }
public ElementListItem(XmlName name, bool required, bool choice) { this.Name = name; this.IsRequired = required; this.IsChoice = choice; }
internal override string ImportType(MessagePartDescription part, XmlQualifiedName typeName, bool isEncoded) { XmlName memberName = new XmlName(part.Name, true /*isEncoded*/); string memberNs = part.Namespace; XmlMembersMapping membersMapping; SoapSchemaMember schemaMember = new SoapSchemaMember(); schemaMember.MemberName = memberName.EncodedName; schemaMember.MemberType = typeName; if (isEncoded) membersMapping = soapImporter.ImportMembersMapping(memberName.DecodedName, memberNs, new SoapSchemaMember[] { schemaMember }); else membersMapping = xmlImporter.ImportMembersMapping(memberName.DecodedName, memberNs, new SoapSchemaMember[] { schemaMember }); return AddPartType(part, membersMapping, isEncoded); }
private bool Stop() { Name = XmlName.Empty; return(false); }
public SimpleNameClass(XmlName name) { this.name = name; }
public QuickFixInsert(XmlNode n, XmlName name) : base(n) { this.name = name; }
public QuickFixAppend(XmlNode n, XmlName name) : base(n) { this.name = name; }
public QuickFixChange(XmlNode n, XmlName name) : base(n) { this.name = name; }
public static void WriteStartElement(this XmlWriter writer, XmlName name) { writer.WriteStartElement(null, name.LocalName, name.NamespaceUri); }
public static void WriteAttributeString(this XmlWriter writer, XmlName name, string value) { writer.WriteStartAttribute(null, name.LocalName, name.NamespaceUri); writer.WriteString(value); writer.WriteEndAttribute(); }
public ElementListItem(XmlName name, bool required) : this(name, required, false) { }
internal XmlMembersMapping ImportFaultElement(FaultDescription fault, out XmlQualifiedName elementName) { // the number of reflection members is always 1 because there is only one fault detail type XmlReflectionMember[] members = new XmlReflectionMember[1]; XmlName faultElementName = fault.ElementName; string faultNamespace = fault.Namespace; if (faultElementName == null) { XmlTypeMapping mapping = _parent._importer.ImportTypeMapping(fault.DetailType); faultElementName = new XmlName(mapping.ElementName, false /*isEncoded*/); faultNamespace = mapping.Namespace; if (faultElementName == null) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxFaultTypeAnonymous, this.Operation.Name, fault.DetailType.FullName))); } elementName = new XmlQualifiedName(faultElementName.DecodedName, faultNamespace); members[0] = XmlSerializerHelper.GetXmlReflectionMember(null /*memberName*/, faultElementName, faultNamespace, fault.DetailType, null /*additionalAttributesProvider*/, false /*isMultiple*/, false /*isWrapped*/); string mappingKey = "fault:" + faultElementName.DecodedName + ":" + faultNamespace; return ImportMembersMapping(faultElementName.EncodedName, faultNamespace, members, false /*hasWrapperElement*/, this.IsRpc, mappingKey); }
public void Visit(ElementNode node, INode parentNode) { if (node.SkipPrefix(node.NamespaceResolver.LookupPrefix(node.NamespaceURI))) return; var value = Values[node]; var parentElement = parentNode as IElementNode; var markupExtension = value as IMarkupExtension; var valueProvider = value as IValueProvider; if (markupExtension != null) { var serviceProvider = new XamlServiceProvider(node, Context); value = markupExtension.ProvideValue(serviceProvider); } if (valueProvider != null) { var serviceProvider = new XamlServiceProvider(node, Context); value = valueProvider.ProvideValue(serviceProvider); } XmlName propertyName; if (TryGetPropertyName(node, parentNode, out propertyName)) { if (Skips.Contains(propertyName)) return; if (parentElement.SkipProperties.Contains(propertyName)) return; var source = Values[parentNode]; if (propertyName == XmlName._CreateContent && source is ElementTemplate) SetTemplate(source as ElementTemplate, node); else SetPropertyValue(source, propertyName, value, Context.RootElement, node, Context, node); } else if (IsCollectionItem(node, parentNode) && parentNode is IElementNode) { // Collection element, implicit content, or implicit collection element. string contentProperty; if (typeof (IEnumerable).GetTypeInfo().IsAssignableFrom(Context.Types[parentElement].GetTypeInfo())) { var source = Values[parentNode]; if (!(typeof (ResourceDictionary).IsAssignableFrom(Context.Types[parentElement]))) { var addMethod = Context.Types[parentElement].GetRuntimeMethods().First(mi => mi.Name == "Add" && mi.GetParameters().Length == 1); addMethod.Invoke(source, new[] { value }); } } else if ((contentProperty = GetContentPropertyName(Context.Types[parentElement].GetTypeInfo())) != null) { var name = new XmlName(node.NamespaceURI, contentProperty); if (Skips.Contains(name)) return; if (parentElement.SkipProperties.Contains(propertyName)) return; var source = Values[parentNode]; SetPropertyValue(source, name, value, Context.RootElement, node, Context, node); } } else if (IsCollectionItem(node, parentNode) && parentNode is ListNode) { var parentList = (ListNode)parentNode; var source = Values[parentNode.Parent]; if (Skips.Contains(parentList.XmlName)) return; var elementType = source.GetType(); var localname = parentList.XmlName.LocalName; GetRealNameAndType(ref elementType, parentList.XmlName.NamespaceURI, ref localname, Context, node); PropertyInfo propertyInfo = null; try { propertyInfo = elementType.GetRuntimeProperty(localname); } catch (AmbiguousMatchException) { // Get most derived instance of property foreach (var property in elementType.GetRuntimeProperties().Where(prop => prop.Name == localname)) { if (propertyInfo == null || propertyInfo.DeclaringType.IsAssignableFrom(property.DeclaringType)) propertyInfo = property; } } if (propertyInfo == null) throw new XamlParseException(string.Format("Property {0} not found", localname), node); MethodInfo getter; if (!propertyInfo.CanRead || (getter = propertyInfo.GetMethod) == null) throw new XamlParseException(string.Format("Property {0} does not have an accessible getter", localname), node); IEnumerable collection; if ((collection = getter.Invoke(source, new object[] { }) as IEnumerable) == null) throw new XamlParseException(string.Format("Property {0} is null or is not IEnumerable", localname), node); MethodInfo addMethod; if ( (addMethod = collection.GetType().GetRuntimeMethods().First(mi => mi.Name == "Add" && mi.GetParameters().Length == 1)) == null) throw new XamlParseException(string.Format("Value of {0} does not have a Add() method", localname), node); addMethod.Invoke(collection, new[] { Values[node] }); } }
static internal XmlReflectionMember GetXmlReflectionMember(XmlName memberName, XmlName elementName, string ns, Type type, MemberInfo additionalAttributesProvider, bool isMultiple, bool isWrapped) { XmlReflectionMember member = new XmlReflectionMember(); member.MemberName = (memberName ?? elementName).DecodedName; member.MemberType = type; if (member.MemberType.IsByRef) member.MemberType = member.MemberType.GetElementType(); if (isMultiple) member.MemberType = member.MemberType.MakeArrayType(); if (additionalAttributesProvider != null) { member.XmlAttributes = XmlAttributesHelper.CreateXmlAttributes(additionalAttributesProvider); } if (member.XmlAttributes == null) member.XmlAttributes = new XmlAttributes(); else { Type invalidAttributeType = null; if (member.XmlAttributes.XmlAttribute != null) invalidAttributeType = typeof(XmlAttributeAttribute); else if (member.XmlAttributes.XmlAnyAttribute != null && !isWrapped) invalidAttributeType = typeof(XmlAnyAttributeAttribute); else if (member.XmlAttributes.XmlChoiceIdentifier != null) invalidAttributeType = typeof(XmlChoiceIdentifierAttribute); else if (member.XmlAttributes.XmlIgnore) invalidAttributeType = typeof(XmlIgnoreAttribute); else if (member.XmlAttributes.Xmlns) invalidAttributeType = typeof(XmlNamespaceDeclarationsAttribute); else if (member.XmlAttributes.XmlText != null) invalidAttributeType = typeof(XmlTextAttribute); else if (member.XmlAttributes.XmlEnum != null) invalidAttributeType = typeof(XmlEnumAttribute); if (invalidAttributeType != null) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(isWrapped ? SR.SFxInvalidXmlAttributeInWrapped : SR.SFxInvalidXmlAttributeInBare, invalidAttributeType, elementName.DecodedName))); if (member.XmlAttributes.XmlArray != null && isMultiple) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxXmlArrayNotAllowedForMultiple, elementName.DecodedName, ns))); } bool isArray = member.MemberType.IsArray; if ((isArray && !isMultiple && member.MemberType != typeof(byte[])) || (!isArray && typeof(IEnumerable).IsAssignableFrom(member.MemberType) && member.MemberType != typeof(string) && !typeof(XmlNode).IsAssignableFrom(member.MemberType) && !typeof(IXmlSerializable).IsAssignableFrom(member.MemberType))) { if (member.XmlAttributes.XmlArray != null) { if (member.XmlAttributes.XmlArray.ElementName == String.Empty) member.XmlAttributes.XmlArray.ElementName = elementName.DecodedName; if (member.XmlAttributes.XmlArray.Namespace == null) member.XmlAttributes.XmlArray.Namespace = ns; } else if (HasNoXmlParameterAttributes(member.XmlAttributes)) { member.XmlAttributes.XmlArray = new XmlArrayAttribute(); member.XmlAttributes.XmlArray.ElementName = elementName.DecodedName; member.XmlAttributes.XmlArray.Namespace = ns; } } else { if (member.XmlAttributes.XmlElements == null || member.XmlAttributes.XmlElements.Count == 0) { if (HasNoXmlParameterAttributes(member.XmlAttributes)) { XmlElementAttribute elementAttribute = new XmlElementAttribute(); elementAttribute.ElementName = elementName.DecodedName; elementAttribute.Namespace = ns; member.XmlAttributes.XmlElements.Add(elementAttribute); } } else { foreach (XmlElementAttribute elementAttribute in member.XmlAttributes.XmlElements) { if (elementAttribute.ElementName == String.Empty) elementAttribute.ElementName = elementName.DecodedName; if (elementAttribute.Namespace == null) elementAttribute.Namespace = ns; } } } return member; }
internal override CodeTypeReference ImportFaultType(XmlQualifiedName elementName, XmlQualifiedName typeName, bool isEncoded) { XmlName memberName = new XmlName(elementName.Name, true /*isEncoded*/); string memberNs = elementName.Namespace; XmlMembersMapping membersMapping; SoapSchemaMember schemaMember = new SoapSchemaMember(); schemaMember.MemberName = memberName.EncodedName; schemaMember.MemberType = typeName; if (isEncoded) { membersMapping = soapImporter.ImportMembersMapping(memberName.DecodedName, memberNs, new SoapSchemaMember[] { schemaMember }); this.xmlSerializerOperationGenerator.SoapExporter.ExportMembersMapping(membersMapping); } else { membersMapping = xmlImporter.ImportMembersMapping(memberName.DecodedName, memberNs, new SoapSchemaMember[] { schemaMember }); this.xmlSerializerOperationGenerator.XmlExporter.ExportMembersMapping(membersMapping); } return new CodeTypeReference(this.xmlSerializerOperationGenerator.GetTypeName(membersMapping[0])); }
public ElementListItem(XmlName name) : this(name, false, false) { }
internal void SetNameOnly(XmlName name) { this.name = name; }
// // Note - the code below this line a paraphrase of the SM reflection code in TypeLoader.cs // Ideally we would be re-using their code, but our assumptions are too disjoint // for that to be realistic at the time of writing (12/2004). // OperationDescription CreateOperationDescription(ContractDescription contract, MethodInfo methodInfo, ComContractElement config, bool allowReferences) { XmlName operationName = new XmlName(ServiceReflector.GetLogicalName(methodInfo)); XmlName returnValueName = TypeLoader.GetReturnValueName(operationName); if (ServiceReflector.IsBegin(methodInfo) || ServiceReflector.IsTask(methodInfo)) { Fx.Assert("No async operations allowed"); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.NoAsyncOperationsAllowed()); } if (contract.Operations.FindAll(operationName.EncodedName).Count != 0) { Fx.Assert("Duplicate operation name"); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.DuplicateOperation()); } OperationDescription operationDescription = new OperationDescription(operationName.EncodedName, contract); operationDescription.SyncMethod = methodInfo; operationDescription.IsInitiating = true; operationDescription.IsTerminating = false; operationDescription.KnownTypes.Add(typeof(Array)); operationDescription.KnownTypes.Add(typeof(DBNull)); operationDescription.KnownTypes.Add(typeof(CurrencyWrapper)); operationDescription.KnownTypes.Add(typeof(ErrorWrapper)); if (allowReferences) { operationDescription.KnownTypes.Add(typeof(PersistStreamTypeWrapper)); } foreach (ComUdtElement udt in config.UserDefinedTypes) { Type knownType; Guid typeLibID = Fx.CreateGuid(udt.TypeLibID); TypeCacheManager.Provider.FindOrCreateType(typeLibID, udt.TypeLibVersion, Fx.CreateGuid(udt.TypeDefID), out knownType, false); this.info.AddUdt(knownType, typeLibID); operationDescription.KnownTypes.Add(knownType); } string ns = contract.Namespace; XmlQualifiedName contractQName = new XmlQualifiedName(contract.Name, ns); string requestAction = NamingHelper.GetMessageAction(contractQName, operationName.DecodedName, null, false); string responseAction = NamingHelper.GetMessageAction(contractQName, operationName.DecodedName, null, true); MessageDescription inMessage = CreateIncomingMessageDescription(contract, methodInfo, ns, requestAction, allowReferences); MessageDescription outMessage = CreateOutgoingMessageDescription(contract, methodInfo, returnValueName, ns, responseAction, allowReferences); operationDescription.Messages.Add(inMessage); operationDescription.Messages.Add(outMessage); return(operationDescription); }
private MessagePartDescriptionCollection GetWrappedParts(MessagePartDescription bodyPart) { Type bodyObjectType = bodyPart.Type; MessagePartDescriptionCollection partList = new MessagePartDescriptionCollection(); foreach (MemberInfo member in bodyObjectType.GetMembers(BindingFlags.Instance | BindingFlags.Public)) { if ((member.MemberType & (MemberTypes.Field | MemberTypes.Property)) == 0) continue; if (member.IsDefined(typeof(SoapIgnoreAttribute), false/*inherit*/)) continue; XmlName xmlName = new XmlName(member.Name); MessagePartDescription part = new MessagePartDescription(xmlName.EncodedName, string.Empty); part.AdditionalAttributesProvider = part.MemberInfo = member; part.Index = part.SerializationPosition = partList.Count; part.Type = (member.MemberType == MemberTypes.Property) ? ((PropertyInfo)member).PropertyType : ((FieldInfo)member).FieldType; if (bodyPart.HasProtectionLevel) part.ProtectionLevel = bodyPart.ProtectionLevel; partList.Add(part); } return partList; }
public EditNodeName(XmlTreeNode node, XmlName newName, bool autoGenPrefixes) { if (node.Node == null) { throw new ArgumentException(SR.NodeNotCreated); } switch (node.NodeType) { case XmlNodeType.Element: cmd = new EditElementName(node, newName, autoGenPrefixes); break; case XmlNodeType.Attribute: cmd = new EditAttributeName(node, newName, autoGenPrefixes); break; case XmlNodeType.ProcessingInstruction: cmd = new EditProcessingInstructionName(node, newName.LocalName); break; default: throw new ArgumentException( string.Format(SR.NodeNameNotEditable, node.NodeType.ToString())); } }
public void Visit(ElementNode node, INode parentNode) { if (node.SkipPrefix((node.NamespaceResolver ?? parentNode.NamespaceResolver)?.LookupPrefix(node.NamespaceURI))) { return; } //if this node is an IMarkupExtension, invoke ProvideValue() and replace the variable var vardef = Context.Variables[node]; var vardefref = new VariableDefinitionReference(vardef); Context.IL.Append(ProvideValue(vardefref, Context, Module, node)); if (vardef != vardefref.VariableDefinition) { vardef = vardefref.VariableDefinition; Context.Body.Variables.Add(vardef); Context.Variables[node] = vardef; } XmlName propertyName; if (TryGetPropertyName(node, parentNode, out propertyName)) { if (skips.Contains(propertyName)) { return; } if (propertyName == XmlName._CreateContent) { SetDataTemplate((IElementNode)parentNode, node, Context, node); } else { SetPropertyValue(Context.Variables[(IElementNode)parentNode], propertyName, node, Context, node); } } else if (IsCollectionItem(node, parentNode) && parentNode is IElementNode) { // Collection element, implicit content, or implicit collection element. string contentProperty; var parentVar = Context.Variables[(IElementNode)parentNode]; if (parentVar.VariableType.ImplementsInterface(Module.Import(typeof(IEnumerable)))) { var elementType = parentVar.VariableType; if (elementType.FullName != "Xamarin.Forms.ResourceDictionary" && elementType.Resolve().BaseType.FullName != "Xamarin.Forms.ResourceDictionary") { var adderTuple = elementType.GetMethods(md => md.Name == "Add" && md.Parameters.Count == 1, Module).First(); var adderRef = Module.Import(adderTuple.Item1); adderRef = Module.Import(adderRef.ResolveGenericParameters(adderTuple.Item2, Module)); Context.IL.Emit(OpCodes.Ldloc, parentVar); Context.IL.Emit(OpCodes.Ldloc, vardef); Context.IL.Emit(OpCodes.Callvirt, adderRef); if (adderRef.ReturnType.FullName != "System.Void") { Context.IL.Emit(OpCodes.Pop); } } } else if ((contentProperty = GetContentProperty(parentVar.VariableType)) != null) { var name = new XmlName(node.NamespaceURI, contentProperty); if (skips.Contains(name)) { return; } SetPropertyValue(Context.Variables[(IElementNode)parentNode], name, node, Context, node); } } else if (IsCollectionItem(node, parentNode) && parentNode is ListNode) { // IL_000d: ldloc.2 // IL_000e: callvirt instance class [mscorlib]System.Collections.Generic.IList`1<!0> class [Xamarin.Forms.Core]Xamarin.Forms.Layout`1<class [Xamarin.Forms.Core]Xamarin.Forms.View>::get_Children() // IL_0013: ldloc.0 // IL_0014: callvirt instance void class [mscorlib]System.Collections.Generic.ICollection`1<class [Xamarin.Forms.Core]Xamarin.Forms.View>::Add(!0) var parentList = (ListNode)parentNode; var parent = Context.Variables[((IElementNode)parentNode.Parent)]; if (skips.Contains(parentList.XmlName)) { return; } var elementType = parent.VariableType; var localname = parentList.XmlName.LocalName; GetNameAndTypeRef(ref elementType, parentList.XmlName.NamespaceURI, ref localname, Context, node); TypeReference propertyDeclaringType; var property = elementType.GetProperty(pd => pd.Name == localname, out propertyDeclaringType); MethodDefinition propertyGetter; if (property != null && (propertyGetter = property.GetMethod) != null && propertyGetter.IsPublic) { var propertyGetterRef = Module.Import(propertyGetter); propertyGetterRef = Module.Import(propertyGetterRef.ResolveGenericParameters(propertyDeclaringType, Module)); var propertyType = propertyGetterRef.ReturnType.ResolveGenericParameters(propertyDeclaringType); var adderTuple = propertyType.GetMethods(md => md.Name == "Add" && md.Parameters.Count == 1, Module).First(); var adderRef = Module.Import(adderTuple.Item1); adderRef = Module.Import(adderRef.ResolveGenericParameters(adderTuple.Item2, Module)); Context.IL.Emit(OpCodes.Ldloc, parent); Context.IL.Emit(OpCodes.Callvirt, propertyGetterRef); Context.IL.Emit(OpCodes.Ldloc, vardef); Context.IL.Emit(OpCodes.Callvirt, adderRef); if (adderRef.ReturnType.FullName != "System.Void") { Context.IL.Emit(OpCodes.Pop); } } } }
public bool Contains(XmlName name) { return(Contains(name.uri, name.local)); }
internal XmlMembersMapping ImportMembersMapping(XmlName elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool rpc, string mappingKey) { XmlMembersMapping mapping; string mappingName = elementName.DecodedName; if (XmlMappings.TryGetValue(mappingKey, out mapping)) { return mapping; } mapping = this.XmlImporter.ImportMembersMapping(mappingName, ns, members, hasWrapperElement, rpc); mapping.SetKey(mappingKey); XmlMappings.Add(mappingKey, mapping); return mapping; }
public static void SetPropertyValue(VariableDefinition parent, XmlName propertyName, INode valueNode, ILContext context, IXmlLineInfo iXmlLineInfo) { var elementType = parent.VariableType; var localName = propertyName.LocalName; var module = context.Body.Method.Module; var br = Instruction.Create(OpCodes.Nop); TypeReference declaringTypeReference; var handled = false; //If it's an attached BP, update elementType and propertyName GetNameAndTypeRef(ref elementType, propertyName.NamespaceURI, ref localName, context, iXmlLineInfo); //If the target is an event, connect // IL_0007: ldloc.0 // IL_0008: ldarg.0 // // IL_0009: ldftn instance void class Xamarin.Forms.Xaml.XamlcTests.MyPage::OnButtonClicked(object, class [mscorlib]System.EventArgs) //OR, if the handler is virtual // IL_000x: ldarg.0 // IL_0009: ldvirtftn instance void class Xamarin.Forms.Xaml.XamlcTests.MyPage::OnButtonClicked(object, class [mscorlib]System.EventArgs) // // IL_000f: newobj instance void class [mscorlib]System.EventHandler::'.ctor'(object, native int) // IL_0014: callvirt instance void class [Xamarin.Forms.Core]Xamarin.Forms.Button::add_Clicked(class [mscorlib]System.EventHandler) var eventinfo = elementType.GetEvent(ed => ed.Name == localName); if (eventinfo != null) { var value = ((ValueNode)valueNode).Value; context.IL.Emit(OpCodes.Ldloc, parent); if (context.Root is VariableDefinition) { context.IL.Emit(OpCodes.Ldloc, context.Root as VariableDefinition); } else if (context.Root is FieldDefinition) { context.IL.Emit(OpCodes.Ldarg_0); context.IL.Emit(OpCodes.Ldfld, context.Root as FieldDefinition); } else { throw new InvalidProgramException(); } var declaringType = context.Body.Method.DeclaringType; if (declaringType.IsNested) { declaringType = declaringType.DeclaringType; } var handler = declaringType.AllMethods().FirstOrDefault(md => md.Name == value as string); if (handler == null) { throw new XamlParseException( string.Format("EventHandler \"{0}\" not found in type \"{1}\"", value, context.Body.Method.DeclaringType.FullName), iXmlLineInfo); } if (handler.IsVirtual) { context.IL.Emit(OpCodes.Ldarg_0); context.IL.Emit(OpCodes.Ldvirtftn, handler); } else { context.IL.Emit(OpCodes.Ldftn, handler); } //FIXME: eventually get the right ctor instead fo the First() one, just in case another one could exists (not even sure it's possible). var ctor = module.Import(eventinfo.EventType.Resolve().GetConstructors().First()); ctor = ctor.ResolveGenericParameters(eventinfo.EventType, module); context.IL.Emit(OpCodes.Newobj, module.Import(ctor)); context.IL.Emit(OpCodes.Callvirt, module.Import(eventinfo.AddMethod)); return; } FieldReference bpRef = elementType.GetField(fd => fd.Name == localName + "Property" && fd.IsStatic && fd.IsPublic, out declaringTypeReference); if (bpRef != null) { bpRef = module.Import(bpRef.ResolveGenericParameters(declaringTypeReference)); bpRef.FieldType = module.Import(bpRef.FieldType); } //If Value is DynamicResource, SetDynamicResource VariableDefinition varValue; if (bpRef != null && valueNode is IElementNode && context.Variables.TryGetValue(valueNode as IElementNode, out varValue) && varValue.VariableType.FullName == typeof(DynamicResource).FullName) { var setDynamicResource = module.Import(typeof(IDynamicResourceHandler)).Resolve().Methods.First(m => m.Name == "SetDynamicResource"); var getKey = typeof(DynamicResource).GetProperty("Key").GetMethod; context.IL.Emit(OpCodes.Ldloc, parent); context.IL.Emit(OpCodes.Ldsfld, bpRef); context.IL.Emit(OpCodes.Ldloc, varValue); context.IL.Emit(OpCodes.Callvirt, module.Import(getKey)); context.IL.Emit(OpCodes.Callvirt, module.Import(setDynamicResource)); return; } //If Value is a BindingBase and target is a BP, SetBinding if (bpRef != null && valueNode is IElementNode && context.Variables.TryGetValue(valueNode as IElementNode, out varValue) && varValue.VariableType.InheritsFromOrImplements(module.Import(typeof(BindingBase)))) { //TODO: check if parent is a BP var setBinding = typeof(BindableObject).GetMethod("SetBinding", new[] { typeof(BindableProperty), typeof(BindingBase) }); context.IL.Emit(OpCodes.Ldloc, parent); context.IL.Emit(OpCodes.Ldsfld, bpRef); context.IL.Emit(OpCodes.Ldloc, varValue); context.IL.Emit(OpCodes.Callvirt, module.Import(setBinding)); return; } //If it's a BP, SetValue () // IL_0007: ldloc.0 // IL_0008: ldsfld class [Xamarin.Forms.Core]Xamarin.Forms.BindableProperty [Xamarin.Forms.Core]Xamarin.Forms.Label::TextProperty // IL_000d: ldstr "foo" // IL_0012: callvirt instance void class [Xamarin.Forms.Core]Xamarin.Forms.BindableObject::SetValue(class [Xamarin.Forms.Core]Xamarin.Forms.BindableProperty, object) if (bpRef != null) { //TODO: check if parent is a BP var setValue = typeof(BindableObject).GetMethod("SetValue", new[] { typeof(BindableProperty), typeof(object) }); if (valueNode is ValueNode) { context.IL.Emit(OpCodes.Ldloc, parent); context.IL.Emit(OpCodes.Ldsfld, bpRef); context.IL.Append(((ValueNode)valueNode).PushConvertedValue(context, bpRef, valueNode.PushServiceProvider(context), true, false)); context.IL.Emit(OpCodes.Callvirt, module.Import(setValue)); return; } if (valueNode is IElementNode) { var getPropertyReturnType = module.Import(typeof(BindableProperty).GetProperty("ReturnType").GetGetMethod()); //FIXME: this should check for inheritance too var isInstanceOfType = module.Import(typeof(Type).GetMethod("IsInstanceOfType", new[] { typeof(object) })); var brfalse = Instruction.Create(OpCodes.Nop); context.IL.Emit(OpCodes.Ldsfld, bpRef); context.IL.Emit(OpCodes.Call, getPropertyReturnType); context.IL.Emit(OpCodes.Ldloc, context.Variables[valueNode as IElementNode]); if (context.Variables[valueNode as IElementNode].VariableType.IsValueType) { context.IL.Emit(OpCodes.Box, context.Variables[valueNode as IElementNode].VariableType); } context.IL.Emit(OpCodes.Callvirt, isInstanceOfType); context.IL.Emit(OpCodes.Brfalse, brfalse); context.IL.Emit(OpCodes.Ldloc, parent); context.IL.Emit(OpCodes.Ldsfld, bpRef); context.IL.Emit(OpCodes.Ldloc, context.Variables[(IElementNode)valueNode]); if (context.Variables[valueNode as IElementNode].VariableType.IsValueType) { context.IL.Emit(OpCodes.Box, context.Variables[valueNode as IElementNode].VariableType); } context.IL.Emit(OpCodes.Callvirt, module.Import(setValue)); context.IL.Emit(OpCodes.Br, br); context.IL.Append(brfalse); handled = true; } } //If it's a property, set it // IL_0007: ldloc.0 // IL_0008: ldstr "foo" // IL_000d: callvirt instance void class [Xamarin.Forms.Core]Xamarin.Forms.Label::set_Text(string) PropertyDefinition property = elementType.GetProperty(pd => pd.Name == localName, out declaringTypeReference); MethodDefinition propertySetter; if (property != null && (propertySetter = property.SetMethod) != null && propertySetter.IsPublic) { module.Import(elementType.Resolve()); var propertySetterRef = module.Import(module.Import(propertySetter).ResolveGenericParameters(declaringTypeReference, module)); propertySetterRef.ImportTypes(module); var propertyType = property.ResolveGenericPropertyType(declaringTypeReference); ValueNode vnode = null; if ((vnode = valueNode as ValueNode) != null) { context.IL.Emit(OpCodes.Ldloc, parent); context.IL.Append(vnode.PushConvertedValue(context, propertyType, new ICustomAttributeProvider[] { property, propertyType.Resolve() }, valueNode.PushServiceProvider(context), false, true)); context.IL.Emit(OpCodes.Callvirt, propertySetterRef); context.IL.Append(br); return; } if (valueNode is IElementNode) { var vardef = context.Variables[(ElementNode)valueNode]; var implicitOperator = vardef.VariableType.GetImplicitOperatorTo(propertyType, module); //TODO replace latest check by a runtime type check if (implicitOperator != null || vardef.VariableType.InheritsFromOrImplements(propertyType) || propertyType.FullName == "System.Object" || vardef.VariableType.FullName == "System.Object") { context.IL.Emit(OpCodes.Ldloc, parent); context.IL.Emit(OpCodes.Ldloc, vardef); if (implicitOperator != null) { // IL_000f: call !0 class [Xamarin.Forms.Core]Xamarin.Forms.OnPlatform`1<bool>::op_Implicit(class [Xamarin.Forms.Core]Xamarin.Forms.OnPlatform`1<!0>) context.IL.Emit(OpCodes.Call, module.Import(implicitOperator)); } else if (!vardef.VariableType.IsValueType && propertyType.IsValueType) { context.IL.Emit(OpCodes.Unbox_Any, module.Import(propertyType)); } else if (vardef.VariableType.IsValueType && propertyType.FullName == "System.Object") { context.IL.Emit(OpCodes.Box, vardef.VariableType); } context.IL.Emit(OpCodes.Callvirt, propertySetterRef); context.IL.Append(br); return; } handled = true; } } //If it's an already initialized property, add to it MethodDefinition propertyGetter; //TODO: check if property is assigned if (property != null && (propertyGetter = property.GetMethod) != null && propertyGetter.IsPublic) { var propertyGetterRef = module.Import(propertyGetter); propertyGetterRef = module.Import(propertyGetterRef.ResolveGenericParameters(declaringTypeReference, module)); var propertyType = propertyGetterRef.ReturnType.ResolveGenericParameters(declaringTypeReference); var vardef = context.Variables [(ElementNode)valueNode]; //TODO check md.Parameters[0] type var adderTuple = propertyType.GetMethods(md => md.Name == "Add" && md.Parameters.Count == 1, module).FirstOrDefault(); if (adderTuple != null) { var adderRef = module.Import(adderTuple.Item1); adderRef = module.Import(adderRef.ResolveGenericParameters(adderTuple.Item2, module)); var childType = GetParameterType(adderRef.Parameters [0]); var implicitOperator = vardef.VariableType.GetImplicitOperatorTo(childType, module); if (valueNode is IElementNode) { context.IL.Emit(OpCodes.Ldloc, parent); context.IL.Emit(OpCodes.Callvirt, propertyGetterRef); context.IL.Emit(OpCodes.Ldloc, vardef); if (implicitOperator != null) { context.IL.Emit(OpCodes.Call, module.Import(implicitOperator)); } context.IL.Emit(OpCodes.Callvirt, adderRef); if (adderRef.ReturnType.FullName != "System.Void") { context.IL.Emit(OpCodes.Pop); } context.IL.Append(br); return; } } } if (!handled) { throw new XamlParseException(string.Format("No property, bindable property, or event found for '{0}'", localName), iXmlLineInfo); } context.IL.Append(br); }
private ContentModelCollector(XmlName tagName) { this.tagName = tagName; }
protected virtual void PerformAction(XmlName name) { }
public SimpleNameClass( XmlName name ) { this.name = name; }
public void AddReference(XmlName xmlName, Type xmlObjectType) { throw new NotImplementedException(nameof(AddReference)); }
private bool Stop() { Name = XmlName.Empty; return false; }
public bool TryGet(XmlName xsiType, out IXmlIncludedType includedType) { return((xsiType == Default.XsiType) ? Try.Success(out includedType, Default) : includedTypes.TryGet(xsiType, out includedType)); }
public bool Contains( XmlName name ) { return Contains( name.uri, name.local ); }
public EditElementName(XmlTreeNode node, XmlName newName, bool autoGenPrefixes) { this.xe = (XmlElement)node.Node; ; this.node = node; this.name = newName; this.autoGenPrefixes = autoGenPrefixes; }
private bool ConsumeStep() { Name = new XmlName ( Step.LocalName, Node.LookupNamespaceUri(Step.Prefix) ); Step = Step.PreviousNode; return true; }
public void Reset(XmlName name, XmlNameTable nameTable) { LocalName = nameTable.Add(name.LocalName); NamespaceUri = name.NamespaceUri != null?nameTable.Add(name.NamespaceUri) : null; }