Prévenir <xsi:nil=“true”> sur Nullable Types de Valeur lors de la Sérialisation XML

J'ai ajouté quelques nullable types de valeur de ma classe sérialisable. - Je effectuer une sérialisation à l'aide XmlSerializer mais lorsque la valeur est définie à null, je reçois un nœud vide avec xsi:nil="true". C'est le bon comportement que j'ai trouvé à la Attribut Xsi:nil en charge de la Liaison.

Est-il un moyen de désactiver cette option, de sorte que rien ne s'affiche lorsque le type de valeur est null?

OriginalL'auteur Ryall | 2010-02-12

  1. 5

    J'ai eu le même problème.. voici l'un des endroits que j'ai lu sur la gestion des valeurs null types de valeur lors de la sérialisation XML: http://stackoverflow.com/questions/244953/serialize-a-nullable-int

    ils mentionnent sur l'utilisation de modèles built-in, comme la création de propriétés supplémentaires pour nullable types de valeur. comme une propriété nommée 

    public int? ABC

    vous devez soit ajouter
    soit public bool ShouldSerializeABC() {return ABC.HasValue;}
    ou public bool ABCSpecified { get { return ABC.HasValue; } }

    je n'avais que de la sérialisation xml à envoyer à un stockées sql proc, donc moi aussi a évité de changer mes classes. Je suis en train de faire un [not(@xsi:nil)] de vérifier tous les nullable éléments dans mon .valeur() de la requête.

    J'ai simplement mis dans une étape intermédiaire de scanner le code XML après qu'il a été sérialisé et de supprimer toute xsi:nil="true" nœuds.
    roger. merci!

    OriginalL'auteur Chin

  2. 4

    J'ai trouvé que le
    public bool ABCSpecified
    a été le seul qui a travaillé avec .NET 4.0. J'ai également eu à ajouter de la XmlIgnoreAttribute

    C'était ma solution complète pour supprimer une Chaîne de caractères nommée ABC dans la Référence Web de Ressources.cs fichier:

    //backing fields
private string abc;
private bool abcSpecified; //Added this - for client code to control its serialization

//serialization of properties
[System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
public string ABC
{
    get
    {
        return this.abc;
    }
    set
    {
        this.abc= value;
    }
}

//Added this entire property procedure
[System.Xml.Serialization.XmlIgnoreAttribute()]
public bool ABCSpecified
{
    get
    {
        return this.abcSpecified;
    }
    set
    {
        this.abcSpecified = value;
    }
}
    XmlIgnoreAttribute sur un "Spécifié" la propriété n'est pas nécessaire, ainsi qu'un setter sur la même propriété.

    OriginalL'auteur Rod Wittmier

  3. 1

    Toutes les méta méthodes comme Spécifié ou ShouldSerialize est juste une mauvaise programmation de la conception de microsoft .Net de la structure XML. Il devient encore plus compliqué si vous n'avez pas un accès direct pour les classes que vous souhaitez pour sérialiser.

    Dans leur méthode de sérialisation il faut juste ajouter un attribut comme "ignoreNullable".

    Ma solution actuelle sérialise le xml et puis juste supprime tous les nœuds ayant nil="true" utilisant la fonction suivante.

    ///<summary>
///Remove optional nullabe xml nodes from given xml string using given scheme prefix.
///
///In other words all nodes that have 'xsi:nil="true"' are being removed from document.
///
///If prefix 'xmlns:xsi' is not found in root element namespace input xml content is returned.
///</summary>
///<param name="xmlContent"></param>
///<param name="schemePrefix">Scheme location prefix</param>
///<returns></returns>
public static String RemoveNilTrue(String xmlContent, String schemePrefix = "xsi")
{
    XmlDocument xmlDocument = new XmlDocument();
    xmlDocument.LoadXml(xmlContent);

    XmlNamespaceManager nsMgr = new XmlNamespaceManager(xmlDocument.NameTable);

    bool schemeExist = false;

    foreach (XmlAttribute attr in xmlDocument.DocumentElement.Attributes)
    {
        if (attr.Prefix.Equals("xmlns", StringComparison.InvariantCultureIgnoreCase)
            && attr.LocalName.Equals(schemePrefix, StringComparison.InvariantCultureIgnoreCase))
        {
            nsMgr.AddNamespace(attr.LocalName, attr.Value);
            schemeExist = true;
            break;
        }
    }

    //scheme exists - remove nodes
    if (schemeExist)
    {
        XmlNodeList xmlNodeList = xmlDocument.SelectNodes("//*[@" + schemePrefix + ":nil='true']", nsMgr);

        foreach (XmlNode xmlNode in xmlNodeList)
            xmlNode.ParentNode.RemoveChild(xmlNode);

        return xmlDocument.InnerXml;
    }
    else
        return xmlContent;
}

    OriginalL'auteur djmj

  4. 1

    J'ai dû ajouter un ShouldSerialize méthode pour chaque nullable valeur.

    [Serializable]
public class Parent
{
    public int? Element { get; set; }

    public bool ShouldSerializeElement() => Element.HasValue;
}

    OriginalL'auteur Todd Skelton

  5. 0

    C'est probablement la moins sophistiquée réponse, mais je l'ai résolu pour moi, avec une simple chaîne de caractères à remplacer.

    .Replace(" xsi:nil=\"true\" ", "");

    Je suis la sérialisation de la chaîne de toute façon. Je peux enregistrer le fichier plus tard.

    Il garde tous mes XmlWriterSettings intacte. Une autre solution je l'ai trouvée tout fait foiré:)

        private static string Serialize<T>(T details)
    {
        var serializer = new XmlSerializer(typeof(T));
        using (var ms = new MemoryStream())
        {
            var settings = new XmlWriterSettings
            {
                Encoding = Encoding.GetEncoding("ISO-8859-1"),
                NewLineChars = Environment.NewLine,
                ConformanceLevel = ConformanceLevel.Document,
                Indent = true,
                OmitXmlDeclaration = true
            };

            using (var writer = XmlWriter.Create(ms, settings))
            {
                serializer.Serialize(writer, details);
                return Encoding.UTF8.GetString(ms.ToArray()).Replace(" xsi:nil=\"true\" ", "");
            }
        }
    }

    OriginalL'auteur Steffen Nordquist