{"id":833,"date":"2010-06-09T16:27:00","date_gmt":"2010-06-09T16:27:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vbteam\/2010\/06\/09\/removing-duplicate-namespaces-in-xml-literals-shyam-namboodiripad\/"},"modified":"2024-07-05T12:41:05","modified_gmt":"2024-07-05T19:41:05","slug":"removing-duplicate-namespaces-in-xml-literals-shyam-namboodiripad","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/vbteam\/removing-duplicate-namespaces-in-xml-literals-shyam-namboodiripad\/","title":{"rendered":"Removing duplicate namespaces in XML Literals (Shyam Namboodiripad)"},"content":{"rendered":"

A common problem that one often runs into with XML literals and the LINQ to XML API is duplicate XML namespaces. Consider the following example. The code <\/span>imports a default XML namespace<\/span><\/a> – “hello”.<\/span><\/span><\/p>\n

Code:<\/span> <\/span>
<\/span>
Imports<\/span> <xmlns<\/span>=<\/span>“<\/span>hello<\/span>“<\/span>> <\/p>\n

<\/span>Module<\/span> Module1
<\/span><\/span>    Sub<\/span> Main()
<\/span>        Dim<\/span> x = <<\/span>A<\/span>>
<\/span><\/span>                    <%=<\/span><\/span> <<\/span>B<\/span>><\/<\/span>B<\/span>><\/span> %>
<\/span><\/span>                <\/span><\/<\/span>A<\/span>>
<\/span>        Console<\/span>.WriteLine(“x:”<\/span>)
<\/span>        Console<\/span>.WriteLine(x) <\/p>\n

<\/span>        Dim<\/span> y = <<\/span>A<\/span>><\/<\/span>A<\/span>>
<\/span><\/span>        y.Add(<<\/span>B<\/span>><\/<\/span>B<\/span>><\/span>)
<\/span>        Console<\/span>.WriteLine(“y:”<\/span>)
<\/span>        Console<\/span>.WriteLine(y)
<\/span>    End<\/span> Sub
<\/span><\/span>End<\/span> Module <\/span><\/span><\/p>\n

Output<\/span>:
<\/span>
x:
<\/span><\/span><A xmlns=”hello”>
  <B><\/B>
<\/span><\/span><\/A><\/span><\/span><\/span><\/span> <\/p>\n

<\/span>y:
<\/span><\/span><\/span><A xmlns=”hello”<\/span><\/strong>>
  <\/strong><B xmlns=<\/strong><\/span><\/span><\/span>“<\/span><\/strong><\/span><\/span>hello<\/strong><\/span><\/span><\/span>“<\/span><\/strong><\/span><\/span><\/span>><\/B>
<\/A><\/span><\/span><\/span><\/span><\/p>\n

<\/span><\/span>As you can see, in the output for variable y, the element <B> has a spurious (duplicate) XML namespace declaration. Although this XML is technically ‘correct’ (i.e. legal XML according to the <\/span>XML 1.0 specification<\/span><\/a>), several tools have problems consuming XML that contains duplicate namespaces. <\/span><\/span><\/p>\n

<\/span><\/p>\n

<\/span><\/span><\/p>\n

For example, consider the below code where I load an MSBuild project file (.vbproj) and try to modify its contents. MSBuild projects are essentially just XML files, so I can use VB XML literals to work with such files. I have set the default XML namespace for my code to match the namespace of the XML in the MSBuild file. Notice that the output has the same problem as before – the <NoWarn> node that I added has a duplicate XML namespace. <\/span><\/span><\/p>\n

If I were to save the XML produced by this code as a “.vbproj” file and build it using MSBuild, MSBuild would fail to process the file because\nof the duplicate namesapace on the <NoWarn> element. In other words, even though the XML is legal, MSBuild can’t consume XML that contains duplicate namespaces. <\/p>\n

Code<\/span>:
<\/span><\/span>
Imports<\/span> <xmlns<\/span>=<\/span>“<\/span>http:\/\/schemas.microsoft.com\/developer\/msbuild\/2003<\/span>“<\/span>> <\/p>\n

<\/span>Module<\/span> Module2
<\/span><\/span>    <\/span>Sub<\/span> Main()
<\/span>        <\/span>Dim<\/span> projectFile As<\/span> String<\/span> = <\/span>“….ConsoleApplication1.vbproj”
<\/span><\/span>        <\/span>Dim<\/span> y = XDocument<\/span>.Load(projectFile)
        <\/span>Dim<\/span> element = <\/span> <<\/span>NoWarn<\/span>>42016<\/span><\/<\/span>NoWarn<\/span>><\/span><\/span> 
<\/span>        <\/span>y.<<\/span>Project>.<<\/span>PropertyGroup><\/span>.First.Add(element)
<\/span>        <\/span>Console<\/span>.WriteLine(“y:”<\/span>)
<\/span>        <\/span>Console<\/span>.WriteLine(y)
<\/span>    <\/span>End<\/span> Sub
<\/span><\/span>End<\/span> Module<\/span><\/span><\/p>\n

<\/span><\/p>\n

Output<\/span>:<\/span><\/p>\n

y:
<Project ToolsVersion=”4.0″ DefaultTargets=”Build” xmlns=”<\/strong><\/span><\/span>http:\/\/schemas.microsoft.com\/developer\/msbuild\/2003<\/span><\/strong><\/span><\/a>“<\/strong><\/span>>
  <PropertyGroup>
…
    <NoWarn xmlns=”<\/span><\/strong><\/span>420164201642016http:\/\/schemas.microsoft.com\/developer\/msbuild\/2003″<\/span><\/span><\/strong><\/a><\/a><\/a>>42016<\/span><\/span><\/a><\/NoWarn>
  <\/PropertyGroup>
…
<\/Project><\/span><\/span><\/a><\/p>\n

<\/span><\/p>\n

Why does VB allow XML with duplicate namespaces to be generated?
<\/strong>
Consider the first code example above. As you can see from the output for variable x, the VB compiler correctly figures out that a namespace declaration need not be emitted on node <B>. The compiler can figure this out because node <B> is ‘syntactically’ embedded (using an <\/span>embedded expression<\/span><\/a>) inside node <A> which is already in the same namespace (i.e. “hello”).<\/span><\/span><\/p>\n

For variable y however, it is very hard for the VB compiler to know that the node <B> is actually going to be embedded inside node <A>. To know this, the compiler would have to inspect the code flow and try to figure out that the node <B> is being passed to an function named ‘Add’ that is defined on type ‘XElement’ and that the target object for function (i.e. y) actually holds a node <A> that is already in the same namespace (i.e. “hello”). Even if the compiler were smart enough to figure this out for this case, it would be almost impossible to make it smart enough to figure this out for cases (like the second code example above) where the source XML is not part of the program (but comes from some file \/ network packet). <\/span><\/p>\n

Because the compiler doesn’t know what document the node <B> is going to end up inside, it ‘fully qualifies’ it with the default namespace of the code file (i.e. “hello”).<\/span><\/p>\n

Ok so the VB compiler can’t figure this out. Surely the LINQ to XML API can, can’t it?<\/span><\/strong><\/span><\/p>\n

Yes, the LINQ to XML API can figure out and remove duplicate namespaces. But it does not enforce the removal of duplicate namespaces by default. I think the reason it doesn’t is performance (i.e. there is a performance hit involved in checking each node to see whether the node has any duplicate namespaces). After all, the XML is legal (albeit a bit ugly) even when it has duplicate namespaces – so why force an extra namespace check always?<\/span><\/p>\n

In VS 2010 \/ .NET 4.0, the LINQ to XML API provides ways to work-around this problem and generate better looking XML. You can add an ‘annotation’ to the root XElement \/ XDocument node that will tell the API not to emit duplicate namespaces as demonstrated in the below example. The API will then check each node as it is added and remove any unnecessary duplicate namespace declarations from the node. <\/span><\/p>\n

Alternately, you can use ‘SaveOptions’ \/\n ‘ReaderOptions’ as demonstrated in the examples below. In this case, the XML will be generated with duplicate namespaces, but the API will do extra work to remove the duplicate namespaces at the time of saving the XML.<\/span><\/p>\n

Code<\/span>:
<\/span>
Imports<\/span> <xmlns<\/span>=<\/span>“<\/span>hello<\/span>“<\/span>><\/span> <\/span> <\/p>\n

Module<\/span> Module1
<\/span><\/span>    Sub<\/span> Main()
<\/span>        Dim<\/span> y = <<\/span>A<\/span>><\/<\/span>A<\/span>>
<\/span><\/span>        y.AddAnnotation(SaveOptions<\/span>.OmitDuplicateNamespaces)
<\/span><\/span>        y.Add(<<\/span>B<\/span>><\/<\/span>B<\/span>><\/span>)
<\/span>        y.Add(<<\/span>C<\/span>><\/<\/span>C<\/span>><\/span>)
<\/span>        Console<\/span>.WriteLine(“y:”<\/span>)
<\/span>        Console<\/span>.WriteLine(y)
<\/span>    End<\/span> Sub
<\/span><\/span>End<\/span> Module<\/span><\/span><\/p>\n

‘If you wish to save the XML to a file
<\/span>Module<\/span> Module2
<\/span><\/span>    Sub<\/span> Main()
<\/span>        Dim<\/span> y = <<\/span>A<\/span>><\/<\/span>A<\/span>>
<\/span><\/span>        y.Add(<<\/span>B<\/span>><\/<\/span>B<\/span>><\/span>)
<\/span>        y.Add(<<\/span>C<\/span>><\/<\/span>C<\/span>><\/span>)
        <\/span>y.Save(“out.xml”<\/span>, SaveOptions<\/span>.OmitDuplicateNamespaces)<\/span>
<\/span>    End<\/span> Sub
<\/span><\/span>End<\/span> Module<\/span><\/span><\/p>\n

‘If you wish to create an XmlReader object for your XML
<\/span>Module<\/span> Module1
<\/span><\/span>    Sub<\/span> Main()
<\/span>        Dim<\/span> y = <<\/span>A<\/span>><\/<\/span>A<\/span>>
<\/span><\/span>        y.Add(<<\/span>B<\/span>><\/<\/span>B<\/span>><\/span>)
<\/span>        y.Add(<<\/span>C<\/span>><\/<\/span>C<\/span>><\/span>)
        <\/span>Dim<\/span> reader =
<\/span>        <\/span>y.CreateReader(ReaderOptions<\/span>.OmitDuplicateNamespaces)
<\/span><\/span>…
<\/span>    End<\/span> Sub
<\/span><\/span>End<\/span> Module<\/span><\/span><\/p>\n

Output<\/span>:  <\/p>\n

y:
<\/span><A xmlns=”hello”>
  <B><\/B>
<\/span><\/span><\/span>  <C><\/C><\/span>
<\/span><\/A><\/span><\/span><\/span><\/p>\n

Hope this helps clean up the XML for your apps! \ud83d\ude42<\/span><\/p>\n


Some references from MSDN<\/span><\/span>: <\/p>\n

<\/span><\/span>XDocument.Save Method<\/span><\/a>
<\/span>SaveOptions Enumeration<\/span><\/a>
<\/span><\/span>Imports Statement (XML Namespace)<\/span><\/a> <\/span><\/span>
<\/span><\/p>\n

Ways to remove duplicate namespaces before VB 2010<\/span>:<\/p>\n

Bill McCarthy has a couple of blog posts about how you can clean up namespaces if you are using VS 2008 \/ .NET 3.5 –
<\/span>http:\/\/msmvps.com\/blogs\/bill\/archive\/2007\/12\/09\/more-on-xml-namespaces-in-vb.aspx<\/span><\/a>
http:\/\/msmvps.com\/blogs\/bill\/archive\/2007\/11\/24\/cleaning-up-your-xml-literal-namespaces.aspx<\/span><\/a><\/span>
<\/span><\/p><\/p>\n","protected":false},"excerpt":{"rendered":"

A common problem that one often runs into with XML literals and the LINQ to XML API is duplicate XML namespaces. Consider the following example. The code imports a default XML namespace – “hello”. Code: Imports <xmlns=“hello“> Module Module1     Sub Main()         Dim x = <A>                     <%= <B><\/B> %>                 <\/A>         Console.WriteLine(“x:”) […]<\/p>\n","protected":false},"author":260,"featured_media":8818,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[195],"tags":[136,167,185],"class_list":["post-833","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-visual-basic","tag-shyam-namboodiripad","tag-vb2010","tag-xml"],"acf":[],"blog_post_summary":"

A common problem that one often runs into with XML literals and the LINQ to XML API is duplicate XML namespaces. Consider the following example. The code imports a default XML namespace – “hello”. Code: Imports <xmlns=“hello“> Module Module1     Sub Main()         Dim x = <A>                     <%= <B><\/B> %>                 <\/A>         Console.WriteLine(“x:”) […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/833","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/users\/260"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/comments?post=833"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/833\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/media\/8818"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/media?parent=833"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/categories?post=833"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/tags?post=833"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}