我有一个表示完整TCP/IP数据包的字节数组。为了澄清，该字节数组按照以下顺序排列：
(IP头 - 20个字节)(TCP头 - 20个字节)(有效负载 - X个字节)
我有一个名为Parse的函数，接受一个字节数组并返回一个TCPHeader对象。它看起来像这样：
TCPHeader Parse( byte[] buffer );
给定原始字节数组，这是我目前调用此函数的方法。
byte[] tcpbuffer = new byte[ 20 ];
System.Buffer.BlockCopy( packet, 20, tcpbuffer, 0, 20 );
TCPHeader tcp = Parse( tcpbuffer );
有没有一种方便的方法可以将TCP字节数组即完整的TCP/IP数据包的第20-39个字节传递给Parse函数，而不需要先将其提取到一个新的字节数组中？
在C++中，我可以这样做：
TCPHeader tcp = Parse( &packet[ 20 ] );
在C#中有类似的东西吗？如果可能，我想避免创建和随后垃圾回收临时字节数组。
一个在.NET框架中常见的做法，也是我建议在此处使用的做法，就是指定偏移量和长度。因此，让您的解析函数还接受在传递数组时的偏移量和要使用的元素数量。
当然，如果像在C++中传递指针一样，应遵循相同的规则——如果您不确定数据何时被使用，那么数组不应被修改，否则可能导致未定义行为。但如果您不再修改该数组，则没有问题。
在这种情况下，我会传递一个 ArraySegment<byte>。
您需要将您的Parse方法更改为以下内容：
// Changed TCPHeader to TcpHeader to adhere to public naming conventions.
TcpHeader Parse(ArraySegment<byte> buffer)
然后你需要将调用更改为：
// Create the array segment.
ArraySegment<byte> seg = new ArraySegment<byte>(packet, 20, 20);
// Call parse.
TcpHeader header = Parse(seg);
使用ArraySegment<T>不会复制数组，并且在构造函数中为您执行边界检查（以便您不指定不正确的边界）。然后，您可以更改Parse方法以使用段中指定的边界，这样您就可以了。
您甚至可以创建一个方便的重载，以接受完整的字节数组：
// Accepts full array.
TcpHeader Parse(byte[] buffer)
{
// Call the overload.
return Parse(new ArraySegment<byte>(buffer));
}
// Changed TCPHeader to TcpHeader to adhere to public naming conventions.
TcpHeader Parse(ArraySegment<byte> buffer)
IEnumerable<byte> 作为输入而不是 byte[]，并且您使用的是 C# 3.0，则可以编写以下代码：tcpbuffer.Skip(20).Take(20);
如果你真的需要这种类型的控制，你需要看一下 C# 的 unsafe 特性。它允许你拥有一个指针并将其固定，以便 GC 不会移动它：
fixed(byte* b = &bytes[20]) {
}
然而，如果没有性能问题，建议不要在使用仅托管代码时采用此方法。您可以像Stream类一样传递偏移量和长度。
如果你可以修改parse()方法，将其改为接受处理应该开始的偏移量。
TCPHeader Parse(byte[] buffer, int offset);
tcpbuffer.Skip(20).Take(20);
但是 System.Buffer.BlockCopy / System.Array.Copy 可能更有效率。
Hashtable parse(byte[] buf, int offset )
{
Hashtable tcpheader = new Hashtable();
if(buf.Length < (20+offset)) return tcpheader;
System.IO.MemoryStream stm = new System.IO.MemoryStream( buf, offset, buf.Length-offset );
System.IO.BinaryReader rdr = new System.IO.BinaryReader( stm );
tcpheader["SourcePort"] = ReadUInt16BigEndian(rdr);
tcpheader["DestPort"] = ReadUInt16BigEndian(rdr);
tcpheader["SeqNum"] = ReadUInt32BigEndian(rdr);
tcpheader["AckNum"] = ReadUInt32BigEndian(rdr);
tcpheader["Offset"] = rdr.ReadByte() >> 4;
tcpheader["Flags"] = rdr.ReadByte() & 0x3f;
tcpheader["Window"] = ReadUInt16BigEndian(rdr);
tcpheader["Checksum"] = ReadUInt16BigEndian(rdr);
tcpheader["UrgentPointer"] = ReadUInt16BigEndian(rdr);
// ignoring tcp options in header might be dangerous
return tcpheader;
}
UInt16 ReadUInt16BigEndian(BinaryReader rdr)
{
UInt16 res = (UInt16)(rdr.ReadByte());
res <<= 8;
res |= rdr.ReadByte();
return(res);
}
UInt32 ReadUInt32BigEndian(BinaryReader rdr)
{
UInt32 res = (UInt32)(rdr.ReadByte());
res <<= 8;
res |= rdr.ReadByte();
res <<= 8;
res |= rdr.ReadByte();
res <<= 8;
res |= rdr.ReadByte();
return(res);
}
我认为在C#中你不能做那样的事情。你可以让Parse()函数使用一个偏移量，或者一开始就创建三个字节数组；一个用于IP头，一个用于TCP头，一个用于有效载荷。
没有可验证的代码可以做到这一点。如果您的解析方法可以处理IEnumerable<byte>，则可以使用LINQ表达式。
TCPHeader tcp = Parse(packet.Skip(20));
// member variables
IPHeader ipHeader = new IPHeader();
TCPHeader tcpHeader = new TCPHeader();
// passing in the buffer, an offset and a length allows you
// to move the header over the buffer
ipHeader.SetBuffer( buffer, 0, 20 );
if( ipHeader.Protocol == TCP )
{
tcpHeader.SetBuffer( buffer, ipHeader.ProtocolOffset, 20 );
}