public IDictionary <string, string> GetNamespacesInScope( XmlNamespaceScope scope) { IXmlNamespaceResolver nsr = reader as IXmlNamespaceResolver; return(nsr.GetNamespacesInScope(scope)); }
public XPath2Context(IXmlNamespaceResolver nsManager) { NameTable = new NameTable(); NamespaceManager = new XmlNamespaceManager(NameTable); SchemaSet = new XmlSchemaSet(NameTable); if (nsManager != null) { foreach (KeyValuePair <string, string> ns in nsManager.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml)) { NamespaceManager.AddNamespace(ns.Key, ns.Value); } } if (NamespaceManager.LookupNamespace("xs") == null) { NamespaceManager.AddNamespace("xs", XmlReservedNs.NsXs); } if (NamespaceManager.LookupNamespace("xsi") == null) { NamespaceManager.AddNamespace("xsi", XmlReservedNs.NsXsi); } if (NamespaceManager.LookupNamespace("fn") == null) { NamespaceManager.AddNamespace("fn", XmlReservedNs.NsXQueryFunc); } if (NamespaceManager.LookupNamespace("local") == null) { NamespaceManager.AddNamespace("local", XmlReservedNs.NsXQueryLocalFunc); } if (NamespaceManager.LookupNamespace("wmh") == null) { NamespaceManager.AddNamespace("wmh", XmlReservedNs.NsWmhExt); } }
public IDictionary<string, string> GetNamespacesInScope (XmlNamespaceScope scope) { IXmlNamespaceResolver resolver = reader as IXmlNamespaceResolver; if (resolver == null) throw new NotSupportedException ("The input XmlReader does not implement IXmlNamespaceResolver and thus this validating reader cannot collect in-scope namespaces."); return resolver.GetNamespacesInScope (scope); }
public IEnumerable <NamespaceDeclaration> GetNamespacePrefixes() { foreach (var p in source.GetNamespacesInScope(XmlNamespaceScope.All)) { yield return(new NamespaceDeclaration(p.Value, p.Key)); } }
public bool FindStylesheetElement() { if (!_topLevelReader) { if (_reader.ReadState != ReadState.Interactive) { return(false); } } // The stylesheet may be an embedded stylesheet. If this is the case the reader will be in Interactive state and should be // positioned on xsl:stylesheet element (or any preceding whitespace) but there also can be namespaces defined on one // of the ancestor nodes. These namespace definitions have to be copied to the xsl:stylesheet element scope. Otherwise it // will not be possible to resolve them later and loading the stylesheet will end up with throwing an exception. IDictionary <string, string> namespacesInScope = null; if (_reader.ReadState == ReadState.Interactive) { // This may be an embedded stylesheet - store namespaces in scope IXmlNamespaceResolver nsResolver = _reader as IXmlNamespaceResolver; if (nsResolver != null) { namespacesInScope = nsResolver.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml); } } while (MoveToNextSibling() && _nodeType == XmlNodeType.Whitespace) { ; } // An Element node was reached. Potentially this is xsl:stylesheet instruction. if (_nodeType == XmlNodeType.Element) { // If namespacesInScope is not null then the stylesheet being read is an embedded stylesheet that can have namespaces // defined outside of xsl:stylesheet instruction. In this case the namespace definitions collected above have to be added // to the element scope. if (namespacesInScope != null) { foreach (KeyValuePair <string, string> prefixNamespacePair in namespacesInScope) { // The namespace could be redefined on the element we just read. If this is the case scopeManager already has // namespace definition for this prefix and the old definition must not be added to the scope. if (_scopeManager.LookupNamespace(prefixNamespacePair.Key) == null) { string nsAtomizedValue = _atoms.NameTable.Add(prefixNamespacePair.Value); _scopeManager.AddNsDeclaration(prefixNamespacePair.Key, nsAtomizedValue); _ctxInfo.AddNamespace(prefixNamespacePair.Key, nsAtomizedValue); } } } // return true to indicate that we reached XmlNodeType.Element node - potentially xsl:stylesheet element. return(true); } // return false to indicate that we did not reach XmlNodeType.Element node so it is not a valid stylesheet. return(false); }
/// <summary> /// The resolve namespaces for serializer. /// </summary> /// <param name="resolver"> /// The resolver. /// </param> /// <param name="includeDefaultNamespace"> /// The include default namespace. /// </param> /// <returns> /// The <see cref="XmlSerializerNamespaces"/>. /// </returns> public static XmlSerializerNamespaces ResolveNamespacesForSerializer( IXmlNamespaceResolver resolver, bool includeDefaultNamespace = false) { if (resolver == null) { return(null); } var container = new XmlSerializerNamespaces(); // копируем словарь сочетаний var dictionary = resolver.GetNamespacesInScope(XmlNamespaceScope.All); if (dictionary != null) { // определяем дефолтовый нэймспейс, если его нужно игнорировать string skipDefaultNamespace; if (includeDefaultNamespace) { skipDefaultNamespace = null; } else { if (!dictionary.TryGetValue(string.Empty, out skipDefaultNamespace)) { skipDefaultNamespace = null; } } // копируем словарь foreach (var ns in dictionary) { // пропускаем стандартные префиксы string prefix = ns.Key; if (string.Compare(prefix, "xml", StringComparison.Ordinal) == 0 || string.Compare(prefix, "xmlns", StringComparison.Ordinal) == 0) { continue; } // пропускаем дефолтовый нэймспейс, если его нужно игнорировать string name = ns.Value; if (skipDefaultNamespace != null && string.Compare(skipDefaultNamespace, name) == 0) { continue; } // добавляем текущее сочетание container.Add(prefix, ns.Value); } } return(container); }
private static void WriteNamespaces(TextWriter writer, IXmlNamespaceResolver nav, string leadIn) { var namespaces = nav.GetNamespacesInScope(XmlNamespaceScope.Local); foreach (var n in namespaces) { writer.Write(leadIn); writer.Write(Constants.Xmlns); if (string.IsNullOrWhiteSpace(n.Key) == false) { writer.Write(Constants.Colon); writer.Write(n.Key); } writer.Write(Constants.Space); writer.WriteLine(n.Value); } }
/// <summary> /// The retrieve default namespace prefix. /// </summary> /// <param name="resolver"> /// The resolver. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> public static string RetrieveDefaultNamespacePrefix(IXmlNamespaceResolver resolver) { if (resolver == null) { return(null); } var str = resolver.LookupNamespace(string.Empty); if (string.IsNullOrEmpty(str)) { return(string.Empty); } var prefix = resolver.LookupPrefix(str); if (string.IsNullOrEmpty(prefix)) { var namespacesInScope = resolver.GetNamespacesInScope(XmlNamespaceScope.All); if (namespacesInScope == null) { return(prefix); } foreach (var pair in namespacesInScope) { var key = pair.Key; if (!string.IsNullOrEmpty(key) && (string.Compare(pair.Value, str, StringComparison.Ordinal) == 0)) { return(key); } } } return(prefix); }
// // IXmlNamespaceResolver // IDictionary <string, string> IXmlNamespaceResolver.GetNamespacesInScope(XmlNamespaceScope scope) { return(readerAsNSResolver.GetNamespacesInScope(scope)); }
internal static XmlNamespaceManager GetNamespaces(IXmlNamespaceResolver resolver) { XmlNamespaceManager manager = new XmlNamespaceManager(new System.Xml.NameTable()); foreach (KeyValuePair<string, string> pair in resolver.GetNamespacesInScope(XmlNamespaceScope.All)) { if (pair.Key != "xmlns") { manager.AddNamespace(pair.Key, pair.Value); } } return manager; }
private void Initialize(XmlReader givenXmlReader, XamlSchemaContext schemaContext, XamlXmlReaderSettings settings) { XmlReader myXmlReader; _mergedSettings = (settings == null) ? new XamlXmlReaderSettings() : new XamlXmlReaderSettings(settings); //Wrap the xmlreader with a XmlCompatReader instance to apply MarkupCompat rules. if (!_mergedSettings.SkipXmlCompatibilityProcessing) { XmlCompatibilityReader mcReader = new XmlCompatibilityReader(givenXmlReader, new IsXmlNamespaceSupportedCallback(IsXmlNamespaceSupported) ); mcReader.Normalization = true; myXmlReader = mcReader; } else { //Don't wrap the xmlreader with XmlCompatReader. // Useful for uses where users want to keep mc: content in the XamlNode stream. // Or have already processed the markup compat and want that extra perf. myXmlReader = givenXmlReader; } // Pick up the XmlReader settings to override the "settings" defaults. if (!String.IsNullOrEmpty(myXmlReader.BaseURI)) { _mergedSettings.BaseUri = new Uri(myXmlReader.BaseURI); } if (myXmlReader.XmlSpace == XmlSpace.Preserve) { _mergedSettings.XmlSpacePreserve = true; } if (!String.IsNullOrEmpty(myXmlReader.XmlLang)) { _mergedSettings.XmlLang = myXmlReader.XmlLang; } IXmlNamespaceResolver myXmlReaderNS = myXmlReader as IXmlNamespaceResolver; Dictionary <string, string> xmlnsDictionary = null; if (myXmlReaderNS != null) { IDictionary <string, string> rootNamespaces = myXmlReaderNS.GetNamespacesInScope(XmlNamespaceScope.Local); if (rootNamespaces != null) { foreach (KeyValuePair <string, string> ns in rootNamespaces) { if (xmlnsDictionary == null) { xmlnsDictionary = new Dictionary <string, string>(); } xmlnsDictionary[ns.Key] = ns.Value; } } } if (schemaContext == null) { schemaContext = new XamlSchemaContext(); } _endOfStreamNode = new XamlNode(XamlNode.InternalNodeType.EndOfStream); _context = new XamlParserContext(schemaContext, _mergedSettings.LocalAssembly); _context.AllowProtectedMembersOnRoot = _mergedSettings.AllowProtectedMembersOnRoot; _context.AddNamespacePrefix(KnownStrings.XmlPrefix, XamlLanguage.Xml1998Namespace); Func <string, string> namespaceResolver = myXmlReader.LookupNamespace; _context.XmlNamespaceResolver = namespaceResolver; XamlScanner xamlScanner = new XamlScanner(_context, myXmlReader, _mergedSettings); XamlPullParser parser = new XamlPullParser(_context, xamlScanner, _mergedSettings); _nodeStream = new NodeStreamSorter(_context, parser, _mergedSettings, xmlnsDictionary); _current = new XamlNode(XamlNode.InternalNodeType.StartOfStream); // user must call Read() before using properties. _currentLineInfo = new LineInfo(0, 0); }
IDictionary <string, string> IXmlNamespaceResolver.GetNamespacesInScope(XmlNamespaceScope scope) { return(nsResolver != null?nsResolver.GetNamespacesInScope(scope) : new Dictionary <string, string> ()); }
IDictionary <string, string> IXmlNamespaceResolver.GetNamespacesInScope(XmlNamespaceScope scope) { return((_readerAsResolver == null) ? null : _readerAsResolver.GetNamespacesInScope(scope)); }
public IDictionary <string, string> GetNamespacesInScope(XmlNamespaceScope scope) => _baseNamespaceResolver?.GetNamespacesInScope(scope);
// Internal IXmlNamespaceResolver methods internal IDictionary <string, string> GetNamespacesInScope(XmlNamespaceScope scope) { return(coreReaderNSResolver.GetNamespacesInScope(scope)); }
IDictionary IXmlNamespaceResolver.GetNamespacesInScope(XmlNamespaceScope scope) { return(nsResolver != null?nsResolver.GetNamespacesInScope(scope) : new Hashtable()); }
internal static XmlNamespaceManager GetNamespaces( IXmlNamespaceResolver resolver ) { XmlNamespaceManager mngr = new XmlNamespaceManager(new NameTable()); IDictionary<string,string> dictionary = resolver.GetNamespacesInScope( XmlNamespaceScope.All ); foreach ( KeyValuePair<string,string> pair in dictionary ) { //"xmlns " is always in the namespace manager so adding it would throw an exception if( pair.Key != "xmlns" ) mngr.AddNamespace( pair.Key, pair.Value ); } return mngr; }
public IDictionary <string, string> GetNamespacesInScope(XmlNamespaceScope scope) => _other.GetNamespacesInScope(scope);
private void Initialize(XmlReader givenXmlReader, XamlSchemaContext schemaContext, XamlXmlReaderSettings settings) { XmlReader reader; this._mergedSettings = (settings == null) ? new XamlXmlReaderSettings() : new XamlXmlReaderSettings(settings); if (!this._mergedSettings.SkipXmlCompatibilityProcessing) { XmlCompatibilityReader reader2 = new XmlCompatibilityReader(givenXmlReader, new IsXmlNamespaceSupportedCallback(this.IsXmlNamespaceSupported)) { Normalization = true }; reader = reader2; } else { reader = givenXmlReader; } if (!string.IsNullOrEmpty(reader.BaseURI)) { this._mergedSettings.BaseUri = new Uri(reader.BaseURI); } if (reader.XmlSpace == XmlSpace.Preserve) { this._mergedSettings.XmlSpacePreserve = true; } if (!string.IsNullOrEmpty(reader.XmlLang)) { this._mergedSettings.XmlLang = reader.XmlLang; } IXmlNamespaceResolver resolver = reader as IXmlNamespaceResolver; Dictionary <string, string> xmlnsDictionary = null; if (resolver != null) { IDictionary <string, string> namespacesInScope = resolver.GetNamespacesInScope(XmlNamespaceScope.Local); if (namespacesInScope != null) { foreach (KeyValuePair <string, string> pair in namespacesInScope) { if (xmlnsDictionary == null) { xmlnsDictionary = new Dictionary <string, string>(); } xmlnsDictionary[pair.Key] = pair.Value; } } } if (schemaContext == null) { schemaContext = new XamlSchemaContext(); } this._endOfStreamNode = new XamlNode(XamlNode.InternalNodeType.EndOfStream); this._context = new XamlParserContext(schemaContext, this._mergedSettings.LocalAssembly); this._context.AllowProtectedMembersOnRoot = this._mergedSettings.AllowProtectedMembersOnRoot; this._context.AddNamespacePrefix("xml", "http://www.w3.org/XML/1998/namespace"); Func <string, string> func = new Func <string, string>(reader.LookupNamespace); this._context.XmlNamespaceResolver = func; XamlScanner scanner = new XamlScanner(this._context, reader, this._mergedSettings); XamlPullParser parser = new XamlPullParser(this._context, scanner, this._mergedSettings); this._nodeStream = new NodeStreamSorter(this._context, parser, this._mergedSettings, xmlnsDictionary); this._current = new XamlNode(XamlNode.InternalNodeType.StartOfStream); this._currentLineInfo = new System.Xaml.LineInfo(0, 0); }