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[]不同。

但是现在，我无法通过Header输出stream.Write()，因为它需要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，其中包含标题和其他方面的详细信息！我实际上认为这是理想的，因为它会将Huffman流的所有问题都封装到一个可测试的代码中，而这些代码在每个需要处理的代码中都不会重复。

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））。根据{{3}}，将它们转换为Get*方法会传达这个想法，并且是在发布不可变数组时的方法。

正如Ivan Stoev在这个问题上评论的那样：

Stream需要byte[]。点。你需要牺牲一些OOP概念或性能。选择是你的。

原因是（我猜）字节数组直接传递给底层系统调用，而其他集合具有不兼容的内部结构。因此，我相信，如果你想保持HuffmanConsts的当前实现，就不可能避免每次调用时新数组分配引入的开销。

将ReadOnlyCollection <byte>写入流

2 个答案: