用protobuf-net序列化不可變集合

Question

我想序列化一個包含作爲成員的不可變集合的protobuf-net的類。

集合類型ImmutableList<T>實現ICollection<T>，但返回true爲IsReadOnly屬性。所以任何修改它的嘗試都會拋出異常。

Protobuf-net似乎依靠能夠在創建集合以便填充它之後調用Add(T)。這顯然不會對一個不可變的集合起作用，這是一種遺憾，因爲protobuf-net與所有其他數據類型（它們也是不可變的）完美地協作。

所以我的問題是，我必須能夠序列化這些集合有哪些選項？

---

爲ImmutableList<T>的代碼如下：

public sealed class ImmutableList<T> : IList<T>, IList 
{ 
    private readonly T[] m_Items; 

    public ImmutableList(IEnumerable<T> source) 
    { 
     m_Items = source.ToArray(); 
    } 

    public T[] ToArray() 
    { 
     T[] newArray = new T[m_Items.Length]; 
     m_Items.CopyTo(newArray, 0); 
     return newArray; 
    } 

    private static void ThrowNotSupported() 
    { 
     throw new NotSupportedException("The attempted operation was not supported as the collection is read-only."); 
    } 

    #region IList<T> Members 

    int IList.Add(object value) 
    { 
     ThrowNotSupported(); 
     return -1; 
    } 

    void IList.Clear() 
    { 
     ThrowNotSupported(); 
    } 

    void IList<T>.Insert(int index, T item) 
    { 
     ThrowNotSupported(); 
    } 

    void IList.Insert(int index, object value) 
    { 
     ThrowNotSupported(); 
    } 

    void IList.Remove(object value) 
    { 
     ThrowNotSupported(); 
    } 

    void IList.RemoveAt(int index) 
    { 
     ThrowNotSupported(); 
    } 

    void IList<T>.RemoveAt(int index) 
    { 
     ThrowNotSupported(); 
    } 

    T IList<T>.this[int index] 
    { 
     get 
     { 
      return m_Items[index]; 
     } 
     set 
     { 
      ThrowNotSupported(); 
     } 
    } 

    object IList.this[int index] 
    { 
     get 
     { 
      return m_Items[index]; 
     } 
     set 
     { 
      ThrowNotSupported(); 
     } 
    } 

    public T this[int index] 
    { 
     get 
     { 
      return m_Items[index]; 
     } 
    } 

    bool IList.Contains(object value) 
    { 
     return Array.IndexOf(m_Items, value) != -1; 
    } 

    int IList.IndexOf(object value) 
    { 
     return Array.IndexOf(m_Items, value); 
    } 

    public int IndexOf(T item) 
    { 
     return Array.IndexOf(m_Items, item); 
    } 

    bool IList.IsFixedSize 
    { 
     get 
     { 
      return true; 
     } 
    } 

    #endregion 

    #region ICollection<T> Members 

    void ICollection<T>.Add(T item) 
    { 
     ThrowNotSupported(); 
    } 

    void ICollection<T>.Clear() 
    { 
     ThrowNotSupported(); 
    } 

    bool ICollection<T>.Remove(T item) 
    { 
     ThrowNotSupported(); 
     return false; 
    } 

    object ICollection.SyncRoot 
    { 
     get 
     { 
      return m_Items; 
     } 
    } 

    bool ICollection.IsSynchronized 
    { 
     get 
     { 
      return true; 
     } 
    } 

    public bool Contains(T item) 
    { 
     return IndexOf(item) != -1; 
    } 

    public void CopyTo(T[] array, int arrayIndex) 
    { 
     m_Items.CopyTo(array, arrayIndex); 
    } 

    void ICollection.CopyTo(Array array, int index) 
    { 
     m_Items.CopyTo(array, index); 
    } 

    public int Count 
    { 
     get 
     { 
      return m_Items.Length; 
     } 
    } 

    public bool IsReadOnly 
    { 
     get 
     { 
      return true; 
     } 
    } 

    #endregion 

    #region IEnumerable<T> Members 

    public IEnumerator<T> GetEnumerator() 
    { 
     return ((IEnumerable<T>)m_Items).GetEnumerator(); 
    } 

    IEnumerator IEnumerable.GetEnumerator() 
    { 
     return m_Items.GetEnumerator(); 
    } 

    #endregion 
} 

Answer 1

目前存在的不支持;但似乎是一個合理的情況。這取決於你的意思（評論）「開箱即用」;如果你的意思是「今天沒有代碼改變」，那麼它需要使用一個反對DTO的代理，或者一個將不可變列表作爲可變列表的shim屬性;如果你的意思是「向前移動」，我懷疑我們可以看看採用（完善的）IEnumerable[<T>]或（不太可取，但可行）T[]的列表構造函數，並且簡單地在緩衝數據之後構造列表。