Sérialiser un nullable int

J'utilise ce micro-modèle à mettre en œuvre Nullable de la sérialisation:

[XmlIgnore]
public double? SomeValue { get; set; }

[XmlAttribute("SomeValue")] //or [XmlElement("SomeValue")]
[EditorBrowsable(EditorBrowsableState.Never)]
public double XmlSomeValue { get { return SomeValue.Value; } set { SomeValue= value; } }  
[EditorBrowsable(EditorBrowsableState.Never)]
public bool XmlSomeValueSpecified { get { return SomeValue.HasValue; } }

Ainsi, le droit de l'interface de l'utilisateur sans compromis et fait la bonne chose lors de la sérialisation.

Wow merci à cette question/réponse m'a vraiment aidé à sortir. J'cœur Stackoverflow.

J'ai fait ce que vous faites au-dessus un peu plus générique. Tout ce que nous sommes vraiment à la recherche de est à ont Nullable légèrement différentes de sérialisation de comportement. J'ai utilisé un Réflecteur pour construire mon propre Nullable, et a ajouté quelques petites choses ici et là pour faire de la sérialisation XML travail de la façon dont nous voulons. Semble fonctionner assez bien:

public class Nullable<T>
{
public Nullable(T value)
{
_value = value;
_hasValue = true;
}
public Nullable()
{
_hasValue = false;
}
[XmlText]
public T Value
{
get
{
if (!HasValue)
throw new InvalidOperationException();
return _value;
}
set
{
_value = value;
_hasValue = true;
}
}
[XmlIgnore]
public bool HasValue
{ get { return _hasValue; } }
public T GetValueOrDefault()
{ return _value; }
public T GetValueOrDefault(T i_defaultValue)
{ return HasValue ? _value : i_defaultValue; }
public static explicit operator T(Nullable<T> i_value)
{ return i_value.Value; }
public static implicit operator Nullable<T>(T i_value)
{ return new Nullable<T>(i_value); }
public override bool Equals(object i_other)
{
if (!HasValue)
return (i_other == null);
if (i_other == null)
return false;
return _value.Equals(i_other);
}
public override int GetHashCode()
{
if (!HasValue)
return 0;
return _value.GetHashCode();
}
public override string ToString()
{
if (!HasValue)
return "";
return _value.ToString();
}
bool _hasValue;
T    _value;
}

Vous perdez la possibilité d'avoir vos membres, comme des int? et ainsi de suite (utiliser les valeurs null<int> au lieu de cela) mais d'autres que tout le comportement reste le même.

Très utile de poster été d'une grande aide.

J'ai choisi d'aller avec Scott révision à la Nullable(T) type de données, cependant le code affiché toujours sérialise le Nullable élément quand il est Nul - mais sans le "xs:nil= "true " attribut".

J'avais besoin de forcer le processus de baisse de la balise complètement j'ai donc tout simplement mis en œuvre IXmlSerializable sur la structure (ce qui est en VB, mais vous obtenez l'image):

  '----------------------------------------------------------------------------
' GetSchema
'----------------------------------------------------------------------------
Public Function GetSchema() As System.Xml.Schema.XmlSchema Implements System.Xml.Serialization.IXmlSerializable.GetSchema
Return Nothing
End Function
'----------------------------------------------------------------------------
' ReadXml
'----------------------------------------------------------------------------
Public Sub ReadXml(ByVal reader As System.Xml.XmlReader) Implements System.Xml.Serialization.IXmlSerializable.ReadXml
If (Not reader.IsEmptyElement) Then
If (reader.Read AndAlso reader.NodeType = System.Xml.XmlNodeType.Text) Then
Me._value = reader.ReadContentAs(GetType(T), Nothing)
End If
End If
End Sub
'----------------------------------------------------------------------------
' WriteXml
'----------------------------------------------------------------------------
Public Sub WriteXml(ByVal writer As System.Xml.XmlWriter) Implements System.Xml.Serialization.IXmlSerializable.WriteXml
If (_hasValue) Then
writer.WriteValue(Me.Value)
End If
End Sub

Je préfère cette méthode à l'aide de l' (foo)modèle Spécifié en tant que nécessite l'ajout d'seau charge de la redondance des propriétés de mes objets, tandis que l'utilisation de la nouvelle type Nullable demande simplement de le retaper des propriétés.