Serialize một int nullable

Tôi có một lớp với int nullable? datatype được đặt để tuần tự hóa dưới dạng phần tử xml. Có cách nào để thiết lập nó để bộ tuần tự xml sẽ không tuần tự hóa phần tử nếu giá trị là null không?

Tôi đã cố gắng thêm thuộc tính [System.Xml.Serialization.XmlElement (IsNullable = false)], nhưng tôi nhận được một ngoại lệ tuần tự hóa thời gian chạy cho biết có lỗi khi phản ánh loại, vì "IsNullable có thể không được đặt thành 'false "cho kiểu Nullable. Hãy xem xét sử dụng kiểu" System.Int32 "hoặc xóa thuộc tính IsNullable khỏi thuộc tính XmlElement."

[Serializable]
[System.Xml.Serialization.XmlRoot("Score", Namespace = "http://mycomp.com/test/score/v1")]
public class Score
{
    private int? iID_m;
    ...

    /// <summary>
    /// 
    /// </summary>        
    public int? ID 
    { 
        get 
        { 
            return iID_m; 
        } 
        set 
        { 
            iID_m = value; 
        } 
    }
     ...
}

Lớp trên sẽ tuần tự thành:

<Score xmlns="http://mycomp.com/test/score/v1">
    <ID xsi:nil="true" />
</Score>

Nhưng đối với các ID là null, tôi không muốn phần tử ID nào cả, chủ yếu vì khi tôi sử dụng OPENXML trong MSSQL, nó sẽ trả về 0 thay vì null cho một phần tử trông giống như

XmlSerializer hỗ trợ ShouldSerialize{Foo}()mẫu, vì vậy bạn có thể thêm một phương pháp:

public bool ShouldSerializeID() {return ID.HasValue;}

Ngoài ra còn có {Foo}Specifiedmẫu - không chắc liệu XmlSerializer có hỗ trợ mẫu đó hay không.

Tôi đang sử dụng mẫu vi mô này để triển khai tuần tự hóa Nullable:

[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; } }

Điều này cung cấp giao diện phù hợp cho người dùng mà không bị ảnh hưởng và vẫn hoạt động đúng khi đăng tuần tự.

Tôi đã tìm ra một cách giải quyết bằng cách sử dụng hai thuộc tính. Một int? thuộc tính XmlIgnore và thuộc tính đối tượng được tuần tự hóa.

    /// <summary>
    /// Score db record
    /// </summary>        
    [System.Xml.Serialization.XmlIgnore()]
    public int? ID 
    { 
        get 
        { 
            return iID_m; 
        } 
        set 
        { 
            iID_m = value; 
        } 
    }

    /// <summary>
    /// Score db record
    /// </summary>        
    [System.Xml.Serialization.XmlElement("ID",IsNullable = false)]
    public object IDValue
    {
        get
        {
            return ID;
        }
        set
        {
            if (value == null)
            {
                ID = null;
            }
            else if (value is int || value is int?)
            {
                ID = (int)value;
            }
            else
            {
                ID = int.Parse(value.ToString());
            }
        }
    }

Wow cảm ơn câu hỏi / câu trả lời này thực sự đã giúp tôi ra ngoài. Tôi trái tim Stackoverflow.

Tôi đã làm cho những gì bạn đang làm ở trên chung chung hơn một chút. Tất cả những gì chúng tôi thực sự đang tìm kiếm là có Nullable với hành vi tuần tự hóa hơi khác. Tôi đã sử dụng Reflector để xây dựng Nullable của riêng mình và thêm một số thứ ở đây và ở đó để tuần tự hóa XML hoạt động theo cách chúng tôi muốn. Có vẻ hoạt động khá tốt:

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;
}

Bạn mất khả năng có thành viên của mình là int? và tiếp tục như vậy (phải sử dụng Nullable <int> thay thế) nhưng khác với điều đó là tất cả các hành vi vẫn giữ nguyên.

Thật không may, các hành vi bạn mô tả được ghi lại chính xác như vậy trong tài liệu cho XmlElementAttribute.IsNullable.

Đăng rất hữu ích đã giúp rất nhiều

Tôi đã chọn thực hiện với bản sửa đổi của Scott cho kiểu dữ liệu Nullable (Of T), tuy nhiên mã được đăng vẫn tuần tự hóa phần tử Nullable khi nó là Null - mặc dù không có thuộc tính "xs: nil = 'true'".

Tôi cần buộc bộ tuần tự loại bỏ hoàn toàn thẻ vì vậy tôi chỉ cần triển khai IXmlSerializable trên cấu trúc (đây là trong VB nhưng bạn có được hình ảnh):

  '----------------------------------------------------------------------------
  ' 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

Tôi thích phương pháp này hơn là sử dụng mẫu được Chỉ định (foo) vì yêu cầu thêm vô số thuộc tính dư thừa vào các đối tượng của tôi, trong khi sử dụng kiểu Nullable mới chỉ yêu cầu nhập lại các thuộc tính.