Unterdrücken xsi:nil aber noch zeigen, Leeres Element beim Serialisieren in .Net

Die Möglichkeit zu haben, den XmlSerializer serialisieren, die eine Eigenschaft ohne die xsi:nil="true" - Attribut wird unten gezeigt:

[XmlRoot("MyClassWithNullableProp", Namespace="urn:myNamespace", IsNullable = false)]
public class MyClassWithNullableProp
{
    public MyClassWithNullableProp( )
    {
        this._namespaces = new XmlSerializerNamespaces(new XmlQualifiedName[] {
            new XmlQualifiedName(string.Empty, "urn:myNamespace") //Default Namespace
        });
    }

    [XmlElement("Property1", Namespace="urn:myNamespace", IsNullable = false)]
    public string Property1
    {
        get
        {
            //To make sure that no element is generated, even when the value of the
            //property is an empty string, return null.
            return string.IsNullOrEmpty(this._property1) ? null : this._property1;
        }
        set { this._property1 = value; }
    }
    private string _property1;

    //To do the same for value types, you need a "helper property, as demonstrated below.
    //First, the regular property.
    [XmlIgnore] //The serializer won't serialize this property properly.
    public int? MyNullableInt
    {
        get { return this._myNullableInt; }
        set { this._myNullableInt = value; }
    }
    private int? _myNullableInt;

    //And now the helper property that the serializer will use to serialize it.
    [XmlElement("MyNullableInt", Namespace="urn:myNamespace", IsNullable = false)]
    public string XmlMyNullableInt
    {
       get 
       {
            return this._myNullableInt.HasValue?
                this._myNullableInt.Value.ToString() : null;
       }
       set { this._myNullableInt = int.Parse(value); } //You should do more error checking...
    }

    //Now, a string property where you want an empty element to be displayed, but no
    //xsi:nil.
    [XmlElement("MyEmptyString", Namespace="urn:myNamespace", IsNullable = false)]
    public string MyEmptyString
    {
        get
        {
            return string.IsNullOrEmpty(this._myEmptyString)?
                string.Empty : this._myEmptyString;
        }
        set { this._myEmptyString = value; }
    }
    private string _myEmptyString;

    //Now, a value type property for which you want an empty tag, and not, say, 0, or
    //whatever default value the framework gives the type.
    [XmlIgnore]
    public float? MyEmptyNullableFloat
    {
        get { return this._myEmptyNullableFloat; }
        set { this._myEmptyNullableFloat = value; }
    }
    private float? _myEmptyNullableFloat;

    //The helper property for serialization.
    public string XmlMyEmptyNullableFloat
    {
        get
        {
            return this._myEmptyNullableFloat.HasValue ?
                this._myEmptyNullableFloat.Value.ToString() : string.Empty;
        }
        set
        {
            if (!string.IsNullOrEmpty(value))
                this._myEmptyNullableFloat = float.Parse(value);
        }
    }

    [XmlNamespaceDeclarations]
    public XmlSerializerNamespaces Namespaces
    {
        get { return this._namespaces; }
    }
    private XmlSerializerNamespaces _namespaces;
}

Nun, diese Klasse instanziieren und zu serialisieren.

//I just wanted to show explicitly setting all the properties to null...
MyClassWithNullableProp myClass = new MyClassWithNullableProp( ) {
    Property1 = null,
    MyNullableInt = null,
    MyEmptyString = null,
    MyEmptyNullableFloat = null
};

//Serialize it.
//You'll need to setup some backing store for the text writer below...
//a file, memory stream, something...
XmlTextWriter writer = XmlTextWriter(...) //Instantiate a text writer.

XmlSerializer xs = new XmlSerializer(typeof(MyClassWithNullableProp),
    new XmlRootAttribute("MyClassWithNullableProp") { 
        Namespace="urn:myNamespace", 
        IsNullable = false
    }
);

xs.Serialize(writer, myClass, myClass.Namespaces);

Nach dem abrufen der Inhalte des XmlTextWriter haben, sollten Sie die folgende Ausgabe:

<MyClassWithNullableProp>
    <MyEmptyString />
     <MyEmptyNullableFloat />
</MyClassWithNullableProp>

Ich hoffe, dass dies deutlich zeigt, wie die eingebaute .NET Framework XmlSerializer kann verwendet werden, zu serialisieren Eigenschaften, um ein leeres element, auch wenn der Wert der Eigenschaft ist null (oder einen anderen Wert, Sie wollen nicht zu serialisieren). Darüber hinaus habe ich gezeigt, wie Sie sicherstellen können, dass null Eigenschaften werden nicht serialisiert überhaupt. Eine Sache zu beachten, wenn Sie ein XmlElementAttribute und legen Sie die IsNullable - Eigenschaft des Attributs auf true, dann wird diese Eigenschaft serialisieren mit der xsi:nil - Attribut, wenn die Eigenschaft ist null (es sei denn, überschrieben woanders).