C# 4 and .NET 4

Bit arrays ❘ 261
The BitVector32 has an overridden ToString() method that not only displays the name of the class but
also 1 or 0 if the bits are set or not, respectively:
BitVector32{00000000000000000000000000011101}
Instead of creating a mask with the CreateMask() method, you can define the mask yourself; you can also
set multiple bits at once. The hexadecimal value abcdef is the same as the binary value 1010 1011 1100
1101 1110 1111. All the bits defined with this value are set:
bits1[0xabcdef] = true;
Console.WriteLine(bits1);
With the output shown you can verify the bits that are set:
BitVector32{00000000101010111100110111101111}
Separating the 32 bits to different sections can be extremely useful. For example, an IPv4 address is defined
as a 4-byte number that is stored inside an integer. You can split the integer by defining four sections.
With a multicast IP message, several 32-bit values are used. One of these 32-bit values is separated in these
sections: 16 bits for the number of sources, 8 bits for a querier’s query interval code, 3 bits for a querier’s
robustness variable, a 1-bit suppress flag, and 4 bits that are reserved. You can also define your own bit
meanings to save memory.
The example simulates receiving the value 0x79abcdef and passes this value to the constructor of
BitVector32, so that the bits are set accordingly:
int received = 0x79abcdef;
BitVector32 bits2 = new BitVector32(received);
Console.WriteLine(bits2);
The bits are shown on the console as initialized:
BitVector32{01111001101010111100110111101111}
Then six sections are created. The first section requires 12 bits, as defined by the hexadecimal value 0xfff
(12 bits are set); section B requires 8 bits; section C, 4 bits; section D and E, 3 bits; and section F, 2 bits.
The first call to CreateSection() just receives 0xfff to allocate the first 12 bits. With the second call to
CreateSection(), the first section is passed as an argument, so that the next section continues where the
first section ended. CreateSection() returns a value of type BitVector32.Section that contains the offset
and the mask for the section.
// sections: FF EEE DDD CCCC BBBBBBBB
// AAAAAAAAAAAA
BitVector32.Section sectionA = BitVector32.CreateSection(0xfff);
BitVector32.Section sectionB = BitVector32.CreateSection(0xff, sectionA);
BitVector32.Section sectionC = BitVector32.CreateSection(0xf, sectionB);
BitVector32.Section sectionD = BitVector32.CreateSection(0x7, sectionC);
BitVector32.Section sectionE = BitVector32.CreateSection(0x7, sectionD);
BitVector32.Section sectionF = BitVector32.CreateSection(0x3, sectionE);
Passing a BitVector32.Section to the indexer of the BitVector32 returns an int just mapped to the section
of the bit vector. Here, a helper method, IntToBinaryString(), retrieves a string representation of the
int number:
Console.WriteLine("Section A: {0}",
IntToBinaryString(bits2[sectionA], true));
Console.WriteLine("Section B: {0}",
IntToBinaryString(bits2[sectionB], true));
Console.WriteLine("Section C: {0}",
IntToBinaryString(bits2[sectionC], true));
Console.WriteLine("Section D: {0}",
IntToBinaryString(bits2[sectionD], true));
Console.WriteLine("Section E: {0}",
IntToBinaryString(bits2[sectionE], true));
Console.WriteLine("Section F: {0}",
IntToBinaryString(bits2[sectionF], true));
www.it-ebooks.info