Remove Namespace attribute from Xml Node in Serialized Value

Question

I'm having to recreate a vendor's XML file. I don't have access to their code, schema, or anything, so I'm doing this using the XmlSerializer and attributes. I'm doing it this way because the system is using a generic XmlWriter I've built to write other system XML files, so I'm killing two birds with one stone. Everything has been working out great, with exception of one property value. The vendor XML looks like this:


    
       SUBSTA SF6 CIRCUIT BKR CONC FDN "C"

Here's my property configuration:

    private string _value;

    [XmlElement("TextOutlTxt")]
    public XmlNode Value
    {
        get
        {
            string text = _value;
            text = Regex.Replace(text, @"[\a\b\f

	\v\""'&<>]", m => string.Join(string.Empty, m.Value.Select(c => string.Format("&#x{0:X};", Convert.ToInt32(c))).ToArray()));
            string value = "

ReplaceMe

";

            XmlDocument document = new XmlDocument();
            document.InnerXml = "" + value + "";

            XmlNode innerNode = document.DocumentElement.FirstChild;
            innerNode.InnerText = text;

            return innerNode;
        }
        set
        { }
    }

And this gives me:


  SUBSTA SF6 CIRCUIT BKR CONC FDN &#x22;C&#x22;

So I'm close, but no cigar. There is an unwanted xmlns="..." attribute; it must not be present. In my XmlWriter, I have done the following to remove the namespace unless found atop the object it is serializing:

 protected override void OnWrite(T sourceData, Stream outputStream)
    {
        IKnownTypesLocator knownTypesLocator = KnownTypesLocator.Instance;

        //Let's see if we can get the default namespace
        XmlRootAttribute xmlRootAttribute = sourceData.GetType().GetCustomAttributes().FirstOrDefault();

        XmlSerializer serializer = null;

        if (xmlRootAttribute != null)
        {
            string nameSpace = xmlRootAttribute.Namespace ?? string.Empty;
            XmlSerializerNamespaces nameSpaces = new XmlSerializerNamespaces();
            nameSpaces.Add(string.Empty, nameSpace);
            serializer = new XmlSerializer(typeof(T), new XmlAttributeOverrides(), knownTypesLocator.XmlItems.ToArray(), xmlRootAttribute, nameSpace);

            //Now we can serialize
            using (StreamWriter writer = new StreamWriter(outputStream))
            {
                serializer.Serialize(writer, sourceData, nameSpaces);
            }
        }
        else
        {
            serializer = new XmlSerializer(typeof(T), knownTypesLocator.XmlItems.ToArray());

            //Now we can serialize
            using (StreamWriter writer = new StreamWriter(outputStream))
            {
                serializer.Serialize(writer, sourceData);
            }
        }
    }

I'm sure I'm overlooking something. Any help would be greatly appreciated!

UPDATE 9/26/2017 So... I've been asked to provide more detail, specifically an explanation of the purpose of my code, and a reproducible example. So here's both:

The purpose for the XML. I am writing an interface UI between two systems. I read data from one, give users options to massage the data, and then give the the ability to export the data into files the second system can import. It's regarding a bill of material system where system one are the CAD drawings and objects in those drawings and system two is an enterprise estimating system that is also being configured to support electronic bills of material. I was given the XMLs from the vendor to recreate.

Fully functional example code.... I've tried generalizing the code in a reproducible form.

[XmlRoot("OutlTxt", Namespace = "http://www.mynamespace/09262017")]
public class OutlineText
{
    private string _value;

    [XmlElement("TextOutlTxt")]
    public XmlNode Value
    {
        get
        {
            string text = _value;
            text = Regex.Replace(text, @"[\a\b\f

	\v\""'&<>]", m => string.Join(string.Empty, m.Value.Select(c => string.Format("&#x{0:X};", Convert.ToInt32(c))).ToArray()));
            string value = "

ReplaceMe

";

            XmlDocument document = new XmlDocument();
            document.InnerXml = "" + value + "";

            XmlNode innerNode = document.DocumentElement.FirstChild;
            innerNode.InnerText = text;

            return innerNode;
         }
        set
        { }
    }

    private OutlineText()
    { }

    public OutlineText(string text)
    {
        _value = text;
    }

}

 public class XmlFileWriter
{
    public void Write(T sourceData, FileInfo targetFile) where T : class
    {
        //This is actually retrieved through a locator object, but surely no one will mind an empty
        //collection for the sake of an example
        Type[] knownTypes = new Type[] { };

        using (FileStream targetStream = targetFile.OpenWrite())
        {
             //Let's see if we can get the default namespace
             XmlRootAttribute xmlRootAttribute = sourceData.GetType().GetCustomAttributes().FirstOrDefault();

             XmlSerializer serializer = null;

            if (xmlRootAttribute != null)
            {
                 string nameSpace = xmlRootAttribute.Namespace ?? string.Empty;
                 XmlSerializerNamespaces nameSpaces = new XmlSerializerNamespaces();
                 nameSpaces.Add(string.Empty, nameSpace);
                 serializer = new XmlSerializer(typeof(T), new XmlAttributeOverrides(), knownTypes, xmlRootAttribute, nameSpace);

                 //Now we can serialize
                using (StreamWriter writer = new StreamWriter(targetStream))
                {
                     serializer.Serialize(writer, sourceData, nameSpaces);
                 }
            }
            else
            {
                serializer = new XmlSerializer(typeof(T), knownTypes);

                //Now we can serialize
                using (StreamWriter writer = new StreamWriter(targetStream))
                {
                    serializer.Serialize(writer, sourceData);
                }
            }
        }
    }
}


 public static void Main()
{
    OutlineText outlineText = new OutlineText(@"SUBSTA SF6 CIRCUIT BKR CONC FDN ""C""");

    XmlFileWriter fileWriter = new XmlFileWriter();
    fileWriter.Write(outlineText, new FileInfo(@"C:\MyDirectory\MyXml.xml"));


    Console.ReadLine();
}

The result produced:



  
    SUBSTA SF6 CIRCUIT BKR CONC FDN &#x22;C&#x22;

Edit 9/27/2017 Per the request in the solution below, a secondary issue I've ran into is keeping the hexadecimal codes. To illustrate this issue based on the above example, let's say the value between is

SUBSTA SF6 CIRCUIT BKR CONC FDN "C"

The vendor file is expecting the literals to be in their hex code format like so

SUBSTA SF6 CIRCUIT BKR CONC FDN "C"

I've rearranged the sample code Value property to be like so:

        private string _value;

    [XmlAnyElement("TextOutlTxt", Namespace = "http://www.mynamespace/09262017")]
    public XElement Value
    {
        get
        {
            string value = string.Format("{1}", "http://www.mynamespace/09262017", _value);


            string innerXml = string.Format("{1}", "http://www.mynamespace/09262017", value);

            XElement element = XElement.Parse(innerXml);

            //Remove redundant xmlns attributes
            foreach (XElement descendant in element.DescendantsAndSelf())
            {
                descendant.Attributes().Where(att => att.IsNamespaceDeclaration && att.Value == "http://www.mynamespace/09262017").Remove();
            }

            return element;
        }
        set
        {
            _value = value == null ? null : value.ToString();
        }
    }

if I use the code

 string text = Regex.Replace(element.Value, @"[\a\b\f

	\v\""'&<>]", m => string.Join(string.Empty, m.Value.Select(c => string.Format("&#x{0:X};", Convert.ToInt32(c))).ToArray()));

to create the hex code values ahead of the XElement.Parse(), the XElement converts them back to their literal values. If I try to set the XElement.Value directly after the XElement.Parse()(or through SetValue()), it changes the " to " Not only that, but it seems to mess with the element output and adds additional elements throwing it all out of whack.

Edit 9/27/2017 #2 to clarify, the original implementation had a related problem, namely that the escaped text was re-escaped. I.e. I was getting

SUBSTA SF6 CIRCUIT BKR CONC FDN &#x22;C&#x22;

But wanted

SUBSTA SF6 CIRCUIT BKR CONC FDN "C"

dbc · Accepted Answer

The reason you are getting xmlns="" added to your embedded XML is that your container element(s) and are declared to be in the "http://www.mynamespace/09262017" namespace by use of the [XmlRootAttribute.Namespace] attribute, whereas the embedded literal XML elements are in the empty namespace. To fix this, your embedded XML literal must be in the same namespace as its parent elements.

Here is the XML literal. Notice there is no xmlns="..." declaration anywhere in the XML:

SUBSTA SF6 CIRCUIT BKR CONC FDN &#x22;C&#x22;

Lacking such a declaration, the

element is in the empty namespace. Conversely, your OutlineText type is decorated with an [XmlRoot] attribute:

[XmlRoot("OutlTxt", Namespace = "http://www.mynamespace/09262017")]
public class OutlineText
{
}

Thus the corresponding OutlTxt root element will be in the http://www.mynamespace/09262017 namespace. All its child elements will default to this namespace as well unless overridden. Placing the embedded XmlNode in the empty namespace counts as overriding the parent namespace, and so an xmlns="" attribute is required.

The simplest way to avoid this problem is for your embedded XML string literal to place itself in the correct namespace as follows:


ReplaceMe

Then, in your Value method, strip redundant namespace declarations. This is somewhat easier to do with the LINQ to XML API:

[XmlRoot("OutlTxt", Namespace = OutlineText.Namespace)]
public class OutlineText
{
    public const string Namespace = "http://www.mynamespace/09262017";

    private string _value;

    [XmlAnyElement("TextOutlTxt", Namespace = OutlineText.Namespace)]
    public XElement Value
    {
        get
        {
            var escapedValue = EscapeTextValue(_value);

            var nestedXml = string.Format("{1}", Namespace, escapedValue);
            var outerXml = string.Format("{1}", Namespace, nestedXml);

            var element = XElement.Parse(outerXml);

            //Remove redundant xmlns attributes
            element.DescendantsAndSelf().SelectMany(e => e.Attributes()).Where(a => a.IsNamespaceDeclaration && a.Value == Namespace).Remove();

            return element;
        }
        set
        {
            _value = value == null ? null : value.Value;
        }
    }

    static string EscapeTextValue(string text)
    {
        return Regex.Replace(text, @"[\a\b\f

	\v\""'&<>]", m => string.Join(string.Empty, m.Value.Select(c => string.Format("&#x{0:X};", Convert.ToInt32(c))).ToArray()));
    }

    private OutlineText()
    { }

    public OutlineText(string text)
    {
        _value = text;
    }
}

And the resulting XML will look like:


  
    
      SUBSTA SF6 CIRCUIT BKR CONC FDN "C"

Note that I have changed the attribute on Value from [XmlElement] to [XmlAnyElement]. I did this because it appears your value XML might contain multiple mixed content nodes at the root level, e.g.:

Start Text Middle Text End Text

Using [XmlAnyElement] enables this by allowing a container node to be returned without causing an extra level of XML element nesting.

Sample working .Net fiddle.

Remove Namespace attribute from Xml Node in Serialized Value

Answers (2)

Related Questions