將ReadOnlyCollection <byte>寫入流

Question

我使用包含多個魔法字節序列的二進制格式。我想保留它們作爲不可變靜態成員的靜態類。

public static class HuffmanConsts 
{ 
    // output format: Header, serialized tree (prefix), DataDelimiter, coded data (logical blocks are 8 byte large, Little Endian) 
    public const string Extension = ".huff"; 
    public static readonly IReadOnlyList<byte> Header = Array.AsReadOnly(new byte[] {0x7B, 0x68, 0x75, 0x7C, 0x6D, 0x7D, 0x66, 0x66}); // string {hu|m}ff 
    public static readonly IReadOnlyList<byte> DataDelimiter = Array.AsReadOnly(BitConverter.GetBytes(0L)); // eight binary zeroes, regardless of endianness 
} 

ReadOnlyCollection<byte>（從Array.AsReadOnly()返回）防止外部的代碼從改變值，不同於byte[]。

但現在，我不能輸出通過stream.Write()Header，因爲它需要byte[]：

stream.Write(HuffmanConsts.Header, 0, HuffmanConsts.Header.Count) 

是否有寫Header優雅的方式？或者我必須編寫一個循環，並逐個將字節輸入到流中？

Answer 1

只是使輸出數組不可改變

你可以考慮這樣的事情：

public static class HuffmanConsts { 
    // output format: Header, serialized tree (prefix), DataDelimiter, 
    // coded data (logical blocks are 8 byte large, Little Endian) 
    public const string Extension = ".huff"; 

    private static readonly IReadOnlyList<byte> _header = 
     // string {hu|m}ff 
     Array.AsReadOnly(new byte[] {0x7B, 0x68, 0x75, 0x7C, 0x6D, 0x7D, 0x66, 0x66}); 
    private static readonly IReadOnlyList<byte> _dataDelimiter = 
     // eight binary zeroes, regardless of endianness 
     Array.AsReadOnly(BitConverter.GetBytes(0L)); 

    public static byte[] Header { get { return _header.ToArray(); } } 
    public static byte[] DataDelimiter { get { return _dataDelimiter.ToArray(); } } 
} 

處理ToArray的

的任何性能影響的ToArray()開銷會發生但是，每次訪問這些屬性時。爲了緩解潛在的性能損失（注：測試是爲了看看是否有其實是一個！），你可以使用System.Buffer.BlockCopy：

private static readonly byte[] _header = 
    // string {hu|m}ff 
    new byte[] {0x7B, 0x68, 0x75, 0x7C, 0x6D, 0x7D, 0x66, 0x66}; 
private static int BYTE_SIZE = 1; 
private static byte[] GetHeaderClone() { 
    byte[] clone = new byte[_header.Length]; 
    Buffer.BlockCopy(_header, 0, clone, 0, _header.Length * BYTE_SIZE); 
    return clone; 
} 

更好的解決方案：封裝寫入到流

您還可以創建擴展方法，讓你的消費者停止擺弄寫這些流組件本身的細節，例如，WriteHeader方法可能是這樣的：

public static class StreamExtensions { 
    // include BlockCopy code from above 
    public static void WriteHuffmanHeader(this Stream stream) { 
     var header = GetHeaderClone(); 
     stream.Write(header, 0, header.Length); 
    } 
} 

這不會使數組不可變，而是私有的，這不是問題。

一個可能更好的解決方案：封裝霍夫曼流對象

您也可以實現自己的HuffmanStream這需要照顧的頭部的細節和其他方面對你的選擇！我實際上認爲這是理想的，因爲它會將霍夫曼流的所有問題都封裝在一個可測試的代碼中，而不是每個需要與之合作的地方都重複。

public class HuffmanStream : Stream { 
    private Stream _stream = new MemoryStream(); 
    private static byte[] _header = ... ; 
    public HuffmanStream(...) { 
     ... 
     _stream.Write(_header, 0, _header.Length) 
     // the stream already has the header written at instantiation time 
    } 
} 

---

注：使byte[]實例Stream.Write()時，它可以被所述方法返回後作爲方法獲取到所述陣列的直接訪問修改。行爲良好的Stream實現不這樣做，但爲了安全防止自定義流，您必須將Stream實例視爲敵對，因此從不傳遞它們對不應更改的數組的引用。例如，任何時候想要將_header字節數組傳遞給possiblyHostileStream.Write()，您都需要通過_header.Clone()。我的HuffmanStream不需要這個，因爲它使用MemoryStream，這是值得信賴的。

Answer 2

可以保留類，因爲它是和轉換Header到byte[]的流：

stream.Write(HuffmanConsts.Header.ToArray(), 0, HuffmanConsts.Header.Count) 

這IEnumerable.ToArray()擴展方法是從System.Linq。

或者，您可以直接存儲字節數組並使用屬性返回其克隆。這是first approach described by ErikE的簡單變體。不再需要ReadOnlyCollection。

public static class HuffmanConsts 
{ 
    // output format: Header, serialized tree (prefix), DataDelimiter, coded data (logical blocks are 8 byte large, Little Endian) 
    public const string Extension = ".huff"; 
    private static byte[] _header = new byte[] {0x7B, 0x68, 0x75, 0x7C, 0x6D, 0x7D, 0x66, 0x66}; // string {hu|m}ff 
    private static byte[] _dataDelimiter = BitConverter.GetBytes(0L); // eight binary zeroes, regardless of endianity 
    public byte[] Header { get { return (byte[])_header.Clone(); } } 
    public byte[] DataDelimiter { get { return (byte[])_dataDelimiter.Clone(); } } 
} 

我並不贊成這種解決方案，因爲這些屬性做的工作不平凡的量（分配;還是O（1），雖然）。根據Framework Design Guidelines，將它們轉換爲Get*方法將傳達該想法並且是發佈不可變陣列時的方法。

---

伊凡Stoev問題下評論說：

Stream需要byte[]。點。您需要犧牲一些OOP概念或性能。這是你的選擇。

原因是（我猜）字節數組直接傳遞給底層的系統調用，而其他集合具有不兼容的內部結構。因此，我相信，如果您想保持當前實現的HuffmanConsts，則不可能在每次調用時避開由新陣列分配引入的開銷。