valor - nullable c#

Suprima que los tipos de valores nulos sean emitidos por XmlSerializer

Question

Tenga en cuenta la siguiente propiedad Tipo de valor de importe marcado como XmlElement con nulos:

[XmlElement(IsNullable=true)] 
public double? Amount { get ; set ; }

Cuando un tipo de valor que admite nulos se establece en nulo, el resultado de C # XmlSerializer es similar al siguiente:

<amount xsi:nil="true" />

En lugar de emitir este elemento, me gustaría que el XmlSerializer suprima completamente el elemento. ¿Por qué? Estamos utilizando Authorize.NET para pagos en línea y Authorize.NET rechaza la solicitud si este elemento nulo existe.

La solución / solución alternativa actual es no serializar en absoluto la propiedad Tipo de valor de cantidad. En su lugar, hemos creado una propiedad complementaria, SerializableAmount, que se basa en Cantidad y se serializa en su lugar. Dado que SerializableAmount es de tipo String, que como tipos de referencia similares son suprimidos por XmlSerializer si nulo por defecto, todo funciona bien.

/// <summary>
/// Gets or sets the amount.
/// </summary>
[XmlIgnore]
public double? Amount { get; set; }

/// <summary>
/// Gets or sets the amount for serialization purposes only.
/// This had to be done because setting value types to null 
/// does not prevent them from being included when a class 
/// is being serialized.  When a nullable value type is set 
/// to null, such as with the Amount property, the result 
/// looks like: &gt;amount xsi:nil="true" /&lt; which will 
/// cause the Authorize.NET to reject the request.  Strings 
/// when set to null will be removed as they are a 
/// reference type.
/// </summary>
[XmlElement("amount", IsNullable = false)]
public string SerializableAmount
{
    get { return this.Amount == null ? null : this.Amount.ToString(); }
    set { this.Amount = Convert.ToDouble(value); }
}

Por supuesto, esto es solo una solución. ¿Hay alguna manera más limpia de suprimir la emisión de elementos del tipo de valor nulo?

Answer 1

Prueba agregar:

public bool ShouldSerializeAmount() {
   return Amount != null;
}

Hay una serie de patrones reconocidos por partes del marco. Para información, XmlSerializer también busca public bool AmountSpecified {get;set;} .

Ejemplo completo (también cambiando a decimal ):

using System;
using System.Xml.Serialization;

public class Data {
    public decimal? Amount { get; set; }
    public bool ShouldSerializeAmount() {
        return Amount != null;
    }
    static void Main() {
        Data d = new Data();
        XmlSerializer ser = new XmlSerializer(d.GetType());
        ser.Serialize(Console.Out, d);
        Console.WriteLine();
        Console.WriteLine();
        d.Amount = 123.45M;
        ser.Serialize(Console.Out, d);
    }
}

Más información sobre ShouldSerialize * en MSDN .

Answer 2

También hay una alternativa para obtener

 <amount /> instead of <amount xsi:nil="true" />

Utilizar

[XmlElement("amount", IsNullable = false)]
public string SerializableAmount
{
    get { return this.Amount == null ? "" : this.Amount.ToString(); }
    set { this.Amount = Convert.ToDouble(value); }
}

Answer 3

puedes probar esto:

xml.Replace("xsi:nil=/"true/"", string.Empty);