Ausschließen null Eigenschaften, wenn Sie mit XmlSerializer

Ich nehme an, man könnte einen XmlWriter, der filtert alle Elemente heraus, mit einem xsi:nil-Attribut, und leitet alle Aufrufe an den zugrunde liegenden wahren Schriftsteller.

InformationsquelleAutor der Antwort Martin v. Löwis

Besser spät als nie...

Habe ich einen Weg gefunden (vielleicht auch nur mit dem neuesten framework, weiß ich nicht), dies zu tun.
Ich war mit DataMember-Attribut für einen WCF-webservice-Vertrag-und ich war mein Objekt wie folgt:

[DataMember(EmitDefaultValue = false)]
public decimal? RentPrice { get; set; }

InformationsquelleAutor der Antwort Aurel

Noch eine Andere Lösung: regex-zu den Rettungs -, Einsatz \s+<\w+ xsi:nil="true" \/> entfernen Sie alle null-Eigenschaften aus einem string mit XML.
Ich bin damit einverstanden, nicht die eleganteste Lösung und funktioniert nur, wenn Sie nur zu serialisieren. Aber das war alles, was ich heute brauchen, und ich nicht hinzufügen wollte {Foo}Specified Eigenschaften für alle Eigenschaften, die null-Werte zulassen.

public string ToXml()
{
    string result;

    var serializer = new XmlSerializer(this.GetType());

    using (var writer = new StringWriter())
    {
        serializer.Serialize(writer, this);
        result = writer.ToString();
    }

    serializer = null;

    //Replace all nullable fields, other solution would be to use add PropSpecified property for all properties that are not strings
    result = Regex.Replace(result, "\\s+<\\w+ xsi:nil=\"true\" \\/>", string.Empty);

    return result;
}

InformationsquelleAutor der Antwort ArieKanarie

Diese Frage wurde gebeten, eine ziemlich lange Zeit her, aber immer noch SEHR relevant, auch im Jahr 2017. Keine der vorgeschlagenen Antworten hier waren nicht zufriedenstellend für mich, so ist hier eine einfache Lösung, die ich kam mit:

Mithilfe von regulären Ausdrücken ist der Schlüssel. Da haben wir nicht viel Kontrolle über die XmlSerializer-Verhalten, also lasst uns NICHT versuchen zu verhindern, dass es zu serialisieren diejenigen, nullable value types. Stattdessen nehmen Sie nur die serialisierte Ausgabe und ersetzen die unerwünschten Elemente, die mit einem leeren string mit Regex. Das Muster verwendet (in C#):

<\w+\s+\w+:nil="true"(\s+xmlns:\w+="http://www.w3.org/2001/XMLSchema-instance")?\s*/>

Hier ein Beispiel:

using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Xml;
using System.Xml.Serialization;

namespace MyNamespace
{
    ///<summary>
    ///Provides extension methods for XML-related operations.
    ///</summary>
    public static class XmlSerializerExtension
    {
        ///<summary>
        ///Serializes the specified object and returns the XML document as a string.
        ///</summary>
        ///<param name="obj">The object to serialize.</param>
        ///<param name="namespaces">The <see cref="XmlSerializerNamespaces"/> referenced by the object.</param>
        ///<returns>An XML string that represents the serialized object.</returns>
        public static string Serialize(this object obj, XmlSerializerNamespaces namespaces = null)
        {
            var xser = new XmlSerializer(obj.GetType());
            var sb = new StringBuilder();

            using (var sw = new StringWriter(sb))
            {
                using (var xtw = new XmlTextWriter(sw))
                {
                    if (namespaces == null)
                        xser.Serialize(xtw, obj);
                    else
                        xser.Serialize(xtw, obj, namespaces);
                }
            }

            return sb.ToString().StripNullableEmptyXmlElements();
        }

        ///<summary>
        ///Removes all empty XML elements that are marked with the nil="true" attribute.
        ///</summary>
        ///<param name="input">The input for which to replace the content.    </param>
        ///<param name="compactOutput">true to make the output more compact, if indentation was used; otherwise, false.</param>
        ///<returns>A cleansed string.</returns>
        public static string StripNullableEmptyXmlElements(this string input, bool compactOutput = false)
        {
            const RegexOptions OPTIONS =
            RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace | RegexOptions.Multiline;

            var result = Regex.Replace(
                input,
                @"<\w+\s+\w+:nil=""true""(\s+xmlns:\w+=""http://www.w3.org/2001/XMLSchema-instance"")?\s*/>",
                string.Empty,
                OPTIONS
            );

            if (compactOutput)
            {
                var sb = new StringBuilder();

                using (var sr = new StringReader(result))
                {
                    string ln;

                    while ((ln = sr.ReadLine()) != null)
                    {
                        if (!string.IsNullOrWhiteSpace(ln))
                        {
                            sb.AppendLine(ln);
                        }
                    }
                }

                result = sb.ToString();
            }

            return result;
        }
    }
}

Ich hoffe, das hilft.

InformationsquelleAutor der Antwort Bigabdoul

Markieren Sie das element mit
[XmlElement("elementName", IsNullable = false)]
null-Werte weggelassen werden.

InformationsquelleAutor der Antwort user1920925