internal static XName ToXName(this string self, XmlReader reader) { var i = self.IndexOf(':'); if (i == 0 || i == self.Length - 1) { throw new XmlException($"\"{self}\" is not QName."); } var prefix = string.Empty; var localPart = string.Empty; if (i < 0) { localPart = self; } else { prefix = self.Substring(0, i); localPart = self.Substring(i + 1); } XNamespace ns = reader.LookupNamespace(prefix); if (ns == null) { throw new XmlException($"The prefix \"{prefix}\" is not declared."); } return ns + localPart; }
public static XmlQualifiedName ParseQName(string prefixedQName, XmlReader reader) { Fx.Assert(prefixedQName != null, "The prefixedQName must be non null."); Fx.Assert(reader != null, "The reader must be non null."); int index = prefixedQName.IndexOf(':'); string ns; string localname; if (index != -1) { string prefix = prefixedQName.Substring(0, index); ns = reader.LookupNamespace(prefix); if (ns == null) { throw FxTrace.Exception.AsError(new XmlException(SR2.DiscoveryXmlQNamePrefixNotDefined(prefix, prefixedQName))); } localname = prefixedQName.Substring(index + 1); if (localname == string.Empty) { throw FxTrace.Exception.AsError(new XmlException(SR2.DiscoveryXmlQNameLocalnameNotDefined(prefixedQName))); } } else { ns = string.Empty; localname = prefixedQName; } localname = XmlConvert.DecodeName(localname); return new XmlQualifiedName(localname, ns); }
public static XmlQualifiedName ResolveQName(XmlReader reader, string qstring) { string name = qstring; string prefix = string.Empty; int index = qstring.IndexOf(':'); if (index > -1) { prefix = qstring.Substring(0, index); name = qstring.Substring(index + 1, qstring.Length - (index + 1)); } return new XmlQualifiedName(name, reader.LookupNamespace(prefix)); }
protected override ITypeSerializationInfo GetElementTypeInfo(XmlReader reader, IPropertySerializationInfo property) { string attr = reader.GetAttribute(TypeField, XMLSchemaInstanceNamespace); if (attr != null) { int separator = attr.IndexOf(':'); if (separator == -1) return GetTypeInfo(string.Empty, attr); var prefix = attr.Substring(0, separator); var localName = attr.Substring(separator + 1); return GetTypeInfo(reader.LookupNamespace(prefix), localName); } else { if (property.PropertyType.IsCollection) { return property.PropertyType.CollectionItemType; } else { return property.PropertyType; } } }
public void EmptyElementInDefaultNamespace (XmlReader xmlReader) { AssertStartDocument (xmlReader); AssertNode ( xmlReader, // xmlReader XmlNodeType.Element, // nodeType 0, // depth true, // isEmptyElement "foo", // name String.Empty, // prefix "foo", // localName "http://foo/", // namespaceURI String.Empty, // value 1 // attributeCount ); AssertAttribute ( xmlReader, // xmlReader "xmlns", // name String.Empty, // prefix "xmlns", // localName "http://www.w3.org/2000/xmlns/", // namespaceURI "http://foo/" // value ); Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace (String.Empty)); AssertEndDocument (xmlReader); }
void LookupEmptyPrefix (XmlReader xmlReader) { xmlReader.Read (); Assert.IsNull (xmlReader.LookupNamespace (String.Empty)); }
public static DirectorySearchRequest Parse(XmlReader reader) { DirectorySearchRequest request = new DirectorySearchRequest(); reader.MoveToContent(); if (reader.LocalName != @"Envelope" || reader.LookupNamespace(reader.Prefix) != @"http://schemas.xmlsoap.org/soap/envelope/") throw new XmlException(); reader.Read(); reader.MoveToElement(); if (reader.LocalName != @"Body") throw new XmlException(); reader.Read(); reader.MoveToElement(); const string schema2 = @"http://schemas.microsoft.com/winrtc/2002/11/sip"; if (reader.LocalName != @"directorySearch" || reader.LookupNamespace(reader.Prefix) != schema2) throw new XmlException(); reader.Read(); reader.MoveToElement(); if (reader.LocalName != @"filter") throw new XmlException(); string filter = reader.GetAttribute(@"href", schema2); reader.Read(); reader.MoveToElement(); request.MaxResults = reader.ReadElementContentAsInt(@"maxResults", schema2); reader.Read(); reader.MoveToElement(); if (reader.LocalName != @"Array") throw new XmlException(); string id = reader.GetAttribute(@"id", schema2); if (filter[0] != '#' || filter.Substring(1) != id) throw new XmlException(); reader.Read(); reader.MoveToElement(); string z = reader.GetAttribute(@"value"); while (reader.LocalName == @"row") { string attrib = reader.GetAttribute(@"attrib", schema2); string value = reader.GetAttribute(@"value", schema2); if (string.IsNullOrEmpty(attrib) == false) { if (request.SearchTerms.ContainsKey(attrib)) request.SearchTerms[attrib] = value; else request.SearchTerms.Add(attrib, value); } reader.Read(); reader.MoveToElement(); } reader.MoveToContent(); reader.ReadEndElement(); return request; }
internal static XmlQualifiedName Parse (string name, XmlReader reader) { int index = name.IndexOf (':'); if (index < 0) return new XmlQualifiedName (name); string ns = reader.LookupNamespace (name.Substring (0, index)); if (ns == null) throw new ArgumentException ("Invalid qualified name."); return new XmlQualifiedName (name.Substring (index + 1), ns); }
private XmlQualifiedName ReadFaultCode(XmlReader reader) { if (reader.IsEmptyElement) { reader.Skip(); return null; } reader.ReadStartElement(); string qnameValue = reader.ReadString(); int colon = qnameValue.IndexOf(":", StringComparison.Ordinal); string ns = reader.NamespaceURI; if (colon >= 0) { string prefix = qnameValue.Substring(0, colon); ns = reader.LookupNamespace(prefix); if (ns == null) throw new InvalidOperationException(Res.GetString(Res.WebQNamePrefixUndefined, prefix)); } reader.ReadEndElement(); return new XmlQualifiedName(qnameValue.Substring(colon + 1), ns); }
/// <summary> /// override of GetElementType /// </summary> public override bool GetElementType( XmlReader xmlReader, string localName, string namespaceUri, ref string assemblyName, ref string typeFullName, ref Type baseType, ref Type serializerType) { if (!ProcessedRootElement && namespaceUri.Equals(XamlReaderHelper.DefinitionNamespaceURI) && (localName.Equals(XamlReaderHelper.DefinitionCodeTag) || localName.Equals(XamlReaderHelper.DefinitionXDataTag))) { MarkupCompiler.ThrowCompilerException(SRID.DefinitionTagNotAllowedAtRoot, xmlReader.Prefix, localName); } bool foundElement = base.GetElementType(xmlReader, localName, namespaceUri, ref assemblyName, ref typeFullName, ref baseType, ref serializerType); if (!ProcessedRootElement) { int count = xmlReader.AttributeCount; // save reader's position, to be restored later string attrName = (xmlReader.NodeType == XmlNodeType.Attribute) ? xmlReader.Name : null; _isRootTag = true; _class = string.Empty; _subClass = string.Empty; ProcessedRootElement = true; XamlTypeMapper.IsProtectedAttributeAllowed = false; xmlReader.MoveToFirstAttribute(); while (--count >= 0) { string attribNamespaceURI = xmlReader.LookupNamespace(xmlReader.Prefix); if (attribNamespaceURI != null && attribNamespaceURI.Equals(XamlReaderHelper.DefinitionNamespaceURI)) { MarkupCompiler.DefinitionNSPrefix = xmlReader.Prefix; if (xmlReader.LocalName == CLASS) { _class = xmlReader.Value.Trim(); if (_class == string.Empty) { // flag an error for processing later in WriteDefAttribute _class = MarkupCompiler.DOT; } else { // flag this so that the Type Mapper can allow protected // attributes on the markup sub-classed root element only. XamlTypeMapper.IsProtectedAttributeAllowed = true; } } else if (xmlReader.LocalName == XamlReaderHelper.DefinitionTypeArgs) { string genericName = _compiler.GetGenericTypeName(localName, xmlReader.Value); foundElement = base.GetElementType(xmlReader, genericName, namespaceUri, ref assemblyName, ref typeFullName, ref baseType, ref serializerType); if (!foundElement) { NamespaceMapEntry[] namespaceMaps = XamlTypeMapper.GetNamespaceMapEntries(namespaceUri); bool isLocal = namespaceMaps != null && namespaceMaps.Length == 1 && namespaceMaps[0].LocalAssembly; if (!isLocal) { MarkupCompiler.ThrowCompilerException(SRID.UnknownGenericType, MarkupCompiler.DefinitionNSPrefix, xmlReader.Value, localName); } } } else if (xmlReader.LocalName == SUBCLASS) { _subClass = xmlReader.Value.Trim(); if (_subClass == string.Empty) { // flag an error for processing later in WriteDefAttribute _subClass = MarkupCompiler.DOT; } else { _compiler.ValidateFullSubClassName(ref _subClass); } } else if (xmlReader.LocalName == CLASSMODIFIER) { if (!_pass2) { _classModifier = xmlReader.Value.Trim(); if (_classModifier == string.Empty) { // flag an error for processing later in WriteDefAttribute _classModifier = MarkupCompiler.DOT; } } else { // This direct comparison is ok to do in pass2 as it has already been validated in pass1. // This is to avoid a costly instantiation of the CodeDomProvider in pass2. _isInternalRoot = string.Compare("public", xmlReader.Value.Trim(), StringComparison.OrdinalIgnoreCase) != 0; } } } xmlReader.MoveToNextAttribute(); } if (namespaceUri.Equals(XamlReaderHelper.DefinitionNamespaceURI)) { xmlReader.MoveToElement(); } else { if (attrName == null) xmlReader.MoveToFirstAttribute(); else xmlReader.MoveToAttribute(attrName); } } else if (!_compiler.IsBamlNeeded && !_compiler.ProcessingRootContext && _compiler.IsCompilingEntryPointClass && xmlReader.Depth > 0) { if ((!localName.Equals(MarkupCompiler.CODETAG) && !localName.Equals(MarkupCompiler.CODETAG + "Extension")) || !namespaceUri.Equals(XamlReaderHelper.DefinitionNamespaceURI)) { _compiler.IsBamlNeeded = true; } } return foundElement; }
// this method can run on a worker thread! private void CreateDocFromInlineXml(XmlReader xmlReader) { // Maybe things have changed and we don't want to use inline doc anymore if (!_tryInlineDoc) { _savedDocument = null; if (_waitForInlineDoc != null) _waitForInlineDoc.Set(); return; } XmlDocument doc; Exception ex = null; try { doc = new XmlDocument(); try { if (TraceData.IsExtendedTraceEnabled(this, TraceDataLevel.XmlProvider)) { TraceData.Trace(TraceEventType.Warning, TraceData.XmlLoadInline( TraceData.Identify(this), Dispatcher.CheckAccess() ? "synchronous" : "asynchronous")); } // Load the inline doc from the reader doc.Load(xmlReader); } catch (XmlException xmle) { if (TraceData.IsEnabled) TraceData.Trace(TraceEventType.Error, TraceData.XmlDPInlineDocError, xmle); ex = xmle; } if (ex == null) { // Save a copy of the inline document to be used in future // queries, and by serialization. _savedDocument = (XmlDocument)doc.Clone(); } } finally { xmlReader.Close(); // Whether or not parsing was successful, unblock the serializer thread. // If serializer had to wait for the inline doc, it's available now. // If there was an error, null will be returned for DocumentForSerialization. if (_waitForInlineDoc != null) _waitForInlineDoc.Set(); } // warn the user if the default xmlns wasn't set explicitly (bug 1006946) if (TraceData.IsEnabled) { XmlNode root = doc.DocumentElement; if (root != null && root.NamespaceURI == xmlReader.LookupNamespace(String.Empty)) { TraceData.Trace(TraceEventType.Error, TraceData.XmlNamespaceNotSet); } } if (ex == null) { // Load succeeded. Create the node collection. (This calls // OnQueryFinished to reset the Document and Data properties). BuildNodeCollection(doc); } else { if (TraceData.IsExtendedTraceEnabled(this, TraceDataLevel.ProviderQuery)) { TraceData.Trace(TraceEventType.Warning, TraceData.QueryFinished( TraceData.Identify(this), Dispatcher.CheckAccess() ? "synchronous" : "asynchronous", TraceData.Identify(null), TraceData.IdentifyException(ex))); } // Load failed. Report the error, and reset // Data and Document properties to null. OnQueryFinished(null, ex, CompletedCallback, null); } }
private string ExpandXmlNamespaces(XmlReader input, string typeName) { int startIndex = 0; int num; while ((num = typeName.IndexOf(':', startIndex)) > 0) { int num2 = typeName.LastIndexOfAny(this.XmlNamespaceBeginnings, num) + 1; string text = typeName.Substring(0, num2); string text2 = typeName.Substring(num2, num - num2); string text3 = typeName.Substring(num + 1); text2 = input.LookupNamespace(text2); typeName = string.Concat(new object[] { text, text2, '.', text3 }); startIndex = typeName.Length - text3.Length; } return typeName; }
private static void CompareReaderProperties(XmlReader standard, XmlReader custom) { Assert.AreEqual(standard.AttributeCount, custom.AttributeCount); Assert.AreEqual(standard.BaseURI, custom.BaseURI); Assert.AreEqual(standard.Depth, custom.Depth); Assert.AreEqual(standard.EOF, custom.EOF); Assert.AreEqual(standard.HasAttributes, custom.HasAttributes); Assert.AreEqual(standard.HasValue, custom.HasValue); Assert.AreEqual(standard.IsDefault, custom.IsDefault); Assert.AreEqual(standard.IsEmptyElement, custom.IsEmptyElement); Assert.AreEqual(standard.LocalName, custom.LocalName); Assert.AreEqual(standard.Name, custom.Name); Assert.AreEqual(standard.NamespaceURI, custom.NamespaceURI); Assert.AreEqual(standard.NodeType, custom.NodeType); Assert.AreEqual(standard.Prefix, custom.Prefix); Assert.AreEqual(standard.QuoteChar, custom.QuoteChar); Assert.AreEqual(standard.ReadState, custom.ReadState); Assert.AreEqual(standard.Value, custom.Value); Assert.AreEqual(standard.ValueType, custom.ValueType); Assert.AreEqual(standard.XmlLang, custom.XmlLang); Assert.AreEqual(standard.XmlSpace, custom.XmlSpace); Assert.AreEqual(standard.LookupNamespace("foo"), custom.LookupNamespace("foo")); }
public XmlReader(IFormatReaderContext context, System.Xml.XmlReader reader) : this(context, reader, reader.LookupNamespace(string.Empty)) { }
internal static XmlQualifiedName Parse (string name, XmlReader reader, bool considerDefaultNamespace) { int index = name.IndexOf (':'); if (index < 0 && !considerDefaultNamespace) return new XmlQualifiedName (name); string ns = reader.LookupNamespace (index < 0 ? String.Empty : name.Substring (0, index)); if (ns == null && index > 0) throw new ArgumentException ("Invalid qualified name."); return new XmlQualifiedName (index < 0 ? name : name.Substring (index + 1), ns); }
public override string LookupNamespace(string prefix) { CheckAsync(); return(_coreReader.LookupNamespace(prefix)); }
public static bool ValidateNamespace(XmlReader reader, string value, string ns) { char[] chrArray = new char[1]; chrArray[0] = ':'; string[] strArrays = value.Split(chrArray); if ((int)strArrays.Length != 1) { string str = strArrays[0]; return string.Equals(reader.LookupNamespace(str), ns, StringComparison.Ordinal); } else { return 0 == reader.NamespaceURI.CompareTo(ns); } }
/// <summary>checks to see if the passed in namespace is the current one</summary> /// <param name="reader">correctly positioned xmlreader</param> /// <param name="namespaceToCompare">the namespace to test for</param> /// <returns> true if this is the one</returns> static protected bool IsCurrentNameSpace(XmlReader reader, string namespaceToCompare) { Tracing.Assert(reader != null, "reader should not be null"); if (reader == null) { throw new ArgumentNullException("reader"); } string curNamespace = reader.NamespaceURI; if (curNamespace.Length == 0) { curNamespace = reader.LookupNamespace(String.Empty); } return curNamespace == namespaceToCompare; }
static void ParseWsdlArrayType (XmlReader reader, XmlAttribute attr) { if (attr.NamespaceURI == XmlSerializer.WsdlNamespace && attr.LocalName == "arrayType") { string ns = "", type, dimensions; TypeTranslator.ParseArrayType (attr.Value, out type, out ns, out dimensions); if (ns != "") ns = reader.LookupNamespace (ns) + ":"; attr.Value = ns + type + dimensions; } }
public static XmlQualifiedName ResolveQName(XmlReader reader, string qstring) { string name = qstring; string prefix = String.Empty; string ns = null; int colon = qstring.IndexOf(':'); // index of char is always ordinal if (colon > -1) { prefix = qstring.Substring(0, colon); name = qstring.Substring(colon + 1, qstring.Length - (colon + 1)); } ns = reader.LookupNamespace(prefix); return new XmlQualifiedName(name, ns); }
//While Creating a XmlQualifedName, we should check: // 1. If a prefix is present, its namespace should be resolvable. // 2. If a prefix is not present, and if the defaultNamespace is set, public static XmlQualifiedName ToQName(XmlReader reader, string qnamestr, out Exception innerEx) { string ns; string name; XmlQualifiedName qname; innerEx = null; if(!IsValidQName(qnamestr)) { innerEx = new Exception(qnamestr + " is an invalid QName. Either name or namespace is not a NCName"); return XmlQualifiedName.Empty; } string[] values = qnamestr.Split(new char[]{':'},2); if(values.Length == 2) { ns = reader.LookupNamespace(values[0]); if(ns == null) { innerEx = new Exception("Namespace Prefix '"+values[0]+"could not be resolved"); return XmlQualifiedName.Empty; } name = values[1]; } else { //Default Namespace ns = reader.LookupNamespace(""); name = values[0]; } qname = new XmlQualifiedName(name,ns); return qname; }
public static void ParseQName(XmlReader reader, string qname, out string localName, out string ns) { int index = qname.IndexOf(':'); string prefix; if (index < 0) { prefix = ""; localName = TrimStart(TrimEnd(qname)); } else { if (index == qname.Length - 1) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.Format(SR.InvalidXmlQualifiedName, qname))); prefix = TrimStart(qname.Substring(0, index)); localName = TrimEnd(qname.Substring(index + 1)); } ns = reader.LookupNamespace(prefix); if (ns == null) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.Format(SR.UnboundPrefixInQName, qname))); }
/// <summary> /// Reads the <saml:Attribute> element. /// </summary> /// <remarks> /// The default implementation requires that the content of the /// Attribute element be a simple string. To handle complex content /// or content of declared simple types other than xs:string, override /// this method. /// </remarks> /// <param name="reader">An <see cref="XmlReader"/> positioned at a <see cref="Saml2Attribute"/> element.</param> /// <returns>A <see cref="Saml2Attribute"/> instance.</returns> protected virtual Saml2Attribute ReadAttribute(XmlReader reader) { if (null == reader) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader"); } // throw if wrong element if (!reader.IsStartElement(Saml2Constants.Elements.Attribute, Saml2Constants.Namespace)) { reader.ReadStartElement(Saml2Constants.Elements.Attribute, Saml2Constants.Namespace); } try { Saml2Attribute attribute; bool isEmpty = reader.IsEmptyElement; // @attributes string value; // @xsi:type XmlUtil.ValidateXsiType(reader, Saml2Constants.Types.AttributeType, Saml2Constants.Namespace); // @Name - required value = reader.GetAttribute(Saml2Constants.Attributes.Name); if (string.IsNullOrEmpty(value)) { throw DiagnosticUtility.ThrowHelperXml(reader, SR.GetString(SR.ID0001, Saml2Constants.Attributes.Name, Saml2Constants.Elements.Attribute)); } attribute = new Saml2Attribute(value); // @NameFormat - optional value = reader.GetAttribute(Saml2Constants.Attributes.NameFormat); if (!string.IsNullOrEmpty(value)) { if (!UriUtil.CanCreateValidUri(value, UriKind.Absolute)) { throw DiagnosticUtility.ThrowHelperXml(reader, SR.GetString(SR.ID0011, Saml2Constants.Attributes.Namespace, Saml2Constants.Elements.Action)); } attribute.NameFormat = new Uri(value); } // @FriendlyName - optional attribute.FriendlyName = reader.GetAttribute(Saml2Constants.Attributes.FriendlyName); // @OriginalIssuer - optional. // We are lax on read here, and will accept the following namespaces for original issuer, in order: // http://schemas.xmlsoap.org/ws/2009/09/identity/claims // http://schemas.microsoft.com/ws/2008/06/identity string originalIssuer = reader.GetAttribute(Saml2Constants.Attributes.OriginalIssuer, ClaimType2009Namespace); if (originalIssuer == null) { originalIssuer = reader.GetAttribute(Saml2Constants.Attributes.OriginalIssuer, ProductConstants.NamespaceUri); } if (originalIssuer == String.Empty) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.ID4252))); } attribute.OriginalIssuer = originalIssuer; // content reader.Read(); if (!isEmpty) { while (reader.IsStartElement(Saml2Constants.Elements.AttributeValue, Saml2Constants.Namespace)) { bool isEmptyValue = reader.IsEmptyElement; bool isNil = XmlUtil.IsNil(reader); // FIP 9570 - ENTERPRISE SCENARIO: Saml11SecurityTokenHandler.ReadAttribute is not checking the AttributeValue XSI type correctly. // Lax on receive. If we dont find the AttributeValueXsiType in the format we are looking for in the xml, we default to string. // Read the xsi:type. We are expecting a value of the form "some-non-empty-string" or "some-non-empty-local-prefix:some-non-empty-string". // ":some-non-empty-string" and "some-non-empty-string:" are edge-cases where defaulting to string is reasonable. // For attributeValueXsiTypeSuffix, we want the portion after the local prefix in "some-non-empty-local-prefix:some-non-empty-string" // "some-non-empty-local-prefix:some-non-empty-string" case string attributeValueXsiTypePrefix = null; string attributeValueXsiTypeSuffix = null; string attributeValueXsiTypeSuffixWithLocalPrefix = reader.GetAttribute("type", XmlSchema.InstanceNamespace); if (!string.IsNullOrEmpty(attributeValueXsiTypeSuffixWithLocalPrefix)) { // "some-non-empty-string" case if (attributeValueXsiTypeSuffixWithLocalPrefix.IndexOf(":", StringComparison.Ordinal) == -1) { attributeValueXsiTypePrefix = reader.LookupNamespace(String.Empty); attributeValueXsiTypeSuffix = attributeValueXsiTypeSuffixWithLocalPrefix; } else if (attributeValueXsiTypeSuffixWithLocalPrefix.IndexOf(":", StringComparison.Ordinal) > 0 && attributeValueXsiTypeSuffixWithLocalPrefix.IndexOf(":", StringComparison.Ordinal) < attributeValueXsiTypeSuffixWithLocalPrefix.Length - 1) { string localPrefix = attributeValueXsiTypeSuffixWithLocalPrefix.Substring(0, attributeValueXsiTypeSuffixWithLocalPrefix.IndexOf(":", StringComparison.Ordinal)); attributeValueXsiTypePrefix = reader.LookupNamespace(localPrefix); attributeValueXsiTypeSuffix = attributeValueXsiTypeSuffixWithLocalPrefix.Substring(attributeValueXsiTypeSuffixWithLocalPrefix.IndexOf(":", StringComparison.Ordinal) + 1); } } if (attributeValueXsiTypePrefix != null && attributeValueXsiTypeSuffix != null) { attribute.AttributeValueXsiType = String.Concat(attributeValueXsiTypePrefix, "#", attributeValueXsiTypeSuffix); } if (isNil) { reader.Read(); if (!isEmptyValue) { reader.ReadEndElement(); } attribute.Values.Add(null); } else if (isEmptyValue) { reader.Read(); attribute.Values.Add(string.Empty); } else { attribute.Values.Add(this.ReadAttributeValue(reader, attribute)); } } reader.ReadEndElement(); } return attribute; } catch (Exception e) { if (System.Runtime.Fx.IsFatal(e)) throw; Exception wrapped = TryWrapReadException(reader, e); if (null == wrapped) { throw; } else { throw wrapped; } } }
internal DpwsServiceType(String type, XmlReader context) { // Check to see if this is a fully qualified path. If so parse into namespaceUri and typeName. if (Uri.IsWellFormedUriString(type, UriKind.Absolute) && type.LastIndexOf("/") != -1) { int typeNameIndex = type.LastIndexOf("/"); NamespaceUri = type.Substring(typeNameIndex); TypeName = type.Substring(typeNameIndex + 1); } else { int prefixIndex; if ((prefixIndex = type.IndexOf(':')) > 0) { NamespaceUri = context.LookupNamespace(type.Substring(0, prefixIndex)); TypeName = type.Substring(prefixIndex + 1); } else { TypeName = type; } } }
public object DeserializeCore (Type type, XmlReader reader) { QName graph_qname = types.GetQName (type); string itype = reader.GetAttribute ("type", XmlSchema.InstanceNamespace); if (itype != null) { string[] parts = itype.Split (':'); if (parts.Length > 1) graph_qname = new QName (parts [1], reader.LookupNamespace (reader.NameTable.Get (parts[0]))); else graph_qname = new QName (itype, reader.NamespaceURI); } string label = reader.GetAttribute ("Ref", KnownTypeCollection.MSSimpleNamespace); if (label != null) { object o = references [label]; if (o == null) throw new SerializationException (String.Format ("Deserialized object with reference Id '{0}' was not found", label)); reader.Skip (); return o; } bool isNil = reader.GetAttribute ("nil", XmlSchema.InstanceNamespace) == "true"; if (isNil) { reader.Skip (); if (!type.IsValueType) return null; else if (type.IsGenericType && type.GetGenericTypeDefinition () == typeof (Nullable<>)) return null; else throw new SerializationException (String.Format ("Value type {0} cannot be null.", type)); } if (KnownTypeCollection.GetPrimitiveTypeFromName (graph_qname.Name) != null) { string value; if (reader.IsEmptyElement) { reader.Read (); // advance if (type.IsValueType) return Activator.CreateInstance (type); else // FIXME: Workaround for creating empty objects of the correct type. value = String.Empty; } else value = reader.ReadElementContentAsString (); return KnownTypeCollection.PredefinedTypeStringToObject (value, graph_qname.Name, reader); } return DeserializeByMap (graph_qname, type, reader); }
public void AttributeInNamespace (XmlReader xmlReader) { AssertStartDocument (xmlReader); AssertNode ( xmlReader, // xmlReader XmlNodeType.Element, // nodeType 0, // depth true, // isEmptyElement "foo", // name String.Empty, // prefix "foo", // localName String.Empty, // namespaceURI String.Empty, // value 2 // attributeCount ); AssertAttribute ( xmlReader, // xmlReader "bar:baz", // name "bar", // prefix "baz", // localName "http://bar/", // namespaceURI "quux" // value ); AssertAttribute ( xmlReader, // xmlReader "xmlns:bar", // name "xmlns", // prefix "bar", // localName "http://www.w3.org/2000/xmlns/", // namespaceURI "http://bar/" // value ); Assert.AreEqual ("http://bar/", xmlReader.LookupNamespace ("bar")); AssertEndDocument (xmlReader); }
// This method validates xsi:type="dcterms:W3CDTF" // The valude of xsi:type is a qualified name. It should have a prefix that matches // the xml namespace (ns) within the scope and the name that matches name // The comparisons should be case-sensitive comparisons internal static void ValidateXsiType(XmlReader reader, Object ns, string name) { // Get the value of xsi;type String typeValue = reader.GetAttribute(PackageXmlStringTable.GetXmlString(PackageXmlEnum.Type), PackageXmlStringTable.GetXmlString(PackageXmlEnum.XmlSchemaInstanceNamespace)); // Missing xsi:type if (typeValue == null) { throw new XmlException(SR.Format(SR.UnknownDCDateTimeXsiType, reader.Name), null, ((IXmlLineInfo)reader).LineNumber, ((IXmlLineInfo)reader).LinePosition); } int index = typeValue.IndexOf(':'); // The valude of xsi:type is not a qualified name if (index == -1) { throw new XmlException(SR.Format(SR.UnknownDCDateTimeXsiType, reader.Name), null, ((IXmlLineInfo)reader).LineNumber, ((IXmlLineInfo)reader).LinePosition); } // Check the following conditions // The namespace of the prefix (string before ":") matches "ns" // The name (string after ":") matches "name" if (!Object.ReferenceEquals(ns, reader.LookupNamespace(typeValue.Substring(0, index))) || String.CompareOrdinal(name, typeValue.Substring(index + 1, typeValue.Length - index - 1)) != 0) { throw new XmlException(SR.Format(SR.UnknownDCDateTimeXsiType, reader.Name), null, ((IXmlLineInfo)reader).LineNumber, ((IXmlLineInfo)reader).LinePosition); } }
void LookupNamespaceAtEndElement (XmlReader reader) { reader.Read (); Assert.AreEqual ("urn:foo", reader.LookupNamespace ("x"), "#1"); reader.Read (); Assert.AreEqual ("urn:foo", reader.LookupNamespace ("x"), "#2"); reader.Read (); Assert.AreEqual ("urn:foo", reader.LookupNamespace ("x"), "#3"); }
// This method handles z:Ref, xsi:nil and primitive types, and then delegates to DeserializeByMap() for anything else. public object Deserialize (Type type, XmlReader reader) { #if !MOONLIGHT if (type == typeof (XmlElement)) return XmlDocument.ReadNode (reader); else if (type == typeof (XmlNode [])) { reader.ReadStartElement (); var l = new List<XmlNode> (); for(; !reader.EOF && reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent ()) l.Add (XmlDocument.ReadNode (reader)); reader.ReadEndElement (); return l.ToArray (); } #endif QName graph_qname = null; if (type.IsGenericType && type.GetGenericTypeDefinition () == typeof (Nullable<>)) { Type internal_type = type.GetGenericArguments () [0]; if (types.FindUserMap(internal_type) != null) { graph_qname = types.GetQName (internal_type); } } if (graph_qname == null) graph_qname = types.GetQName (type); string itype = reader.GetAttribute ("type", XmlSchema.InstanceNamespace); if (itype != null) { string [] parts = itype.Split (':'); if (parts.Length > 1) graph_qname = new QName (parts [1], reader.LookupNamespace (reader.NameTable.Get (parts [0]))); else graph_qname = new QName (itype, reader.LookupNamespace (String.Empty)); } string label = reader.GetAttribute ("Ref", KnownTypeCollection.MSSimpleNamespace); if (label != null) { object o; if (!references.TryGetValue (label, out o)) throw new SerializationException (String.Format ("Deserialized object with reference Id '{0}' was not found", label)); reader.Skip (); return o; } bool isNil = reader.GetAttribute ("nil", XmlSchema.InstanceNamespace) == "true"; if (isNil) { reader.Skip (); if (!type.IsValueType || type == typeof (void)) return null; else if (type.IsGenericType && type.GetGenericTypeDefinition () == typeof (Nullable<>)) return null; else throw new SerializationException (String.Format ("Value type {0} cannot be null.", type)); } if (resolver != null) { Type t; if (resolved_qnames.TryGetValue (graph_qname, out t)) type = t; else { // i.e. resolve name only once. type = resolver.ResolveName (graph_qname.Name, graph_qname.Namespace, type, default_resolver) ?? type; resolved_qnames.Add (graph_qname, type); types.Add (type); } } if (KnownTypeCollection.GetPrimitiveTypeFromName (graph_qname) != null) { string id = reader.GetAttribute ("Id", KnownTypeCollection.MSSimpleNamespace); object ret = DeserializePrimitive (type, reader, graph_qname); if (id != null) { if (references.ContainsKey (id)) throw new InvalidOperationException (String.Format ("Object with Id '{0}' already exists as '{1}'", id, references [id])); references.Add (id, ret); } return ret; } return DeserializeByMap (graph_qname, type, reader); }
public void ChildElementInNamespace (XmlReader xmlReader) { AssertStartDocument (xmlReader); AssertNode ( xmlReader, // xmlReader XmlNodeType.Element, // nodeType 0, // depth false, // isEmptyElement "foo:bar", // name "foo", // prefix "bar", // localName "http://foo/", // namespaceURI String.Empty, // value 1 // attributeCount ); AssertAttribute ( xmlReader, // xmlReader "xmlns:foo", // name "xmlns", // prefix "foo", // localName "http://www.w3.org/2000/xmlns/", // namespaceURI "http://foo/" // value ); Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo")); AssertNode ( xmlReader, // xmlReader XmlNodeType.Element, // nodeType 1, // depth true, // isEmptyElement "baz:quux", // name "baz", // prefix "quux", // localName "http://baz/", // namespaceURI String.Empty, // value 1 // attributeCount ); AssertAttribute ( xmlReader, // xmlReader "xmlns:baz", // name "xmlns", // prefix "baz", // localName "http://www.w3.org/2000/xmlns/", // namespaceURI "http://baz/" // value ); Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo")); Assert.AreEqual ("http://baz/", xmlReader.LookupNamespace ("baz")); AssertNode ( xmlReader, // xmlReader XmlNodeType.EndElement, // nodeType 0, // depth false, // isEmptyElement "foo:bar", // name "foo", // prefix "bar", // localName "http://foo/", // namespaceURI String.Empty, // value 0 // attributeCount ); Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo")); Assert.IsNull (xmlReader.LookupNamespace ("baz")); AssertEndDocument (xmlReader); }
internal static XmlQualifiedName GetValueAsQName(XmlReader reader, string value) { string prefix; string name; SplitIntoPrefixAndName(value, out prefix, out name); string ns = reader.LookupNamespace(prefix); if (ns == null && prefix.Length > 0) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.Format(SR.CouldNotFindNamespaceForPrefix, prefix))); } return new XmlQualifiedName(name, ns); }
static XmlQualifiedName ParseQName(string lexicalQName, XmlReader reader) { string[] parts = lexicalQName.Split(':'); if (parts.Length == 1) { return new XmlQualifiedName(parts[0]); } string prefix = parts[0]; string ns = reader.LookupNamespace(prefix); return new XmlQualifiedName(parts[1], ns); }
// Resolves a namespace prefix in the current element's scope. public override string LookupNamespace(string prefix) { return(coreReader.LookupNamespace(prefix)); }