Best way to store long binary (up to 512 bit) in C#

I'm trying to figure out the best way to store large binary (more than 96 bit) numbers in C#

I'm building application that will automatically allocate workers for shifts. Shifts can be as short as 15 minutes (but this might be even smaller in the future). To avoid double-booking of workers, I plan to have binary map of their daily time: 24 hours separated in equal chunks (15 minutes) and every chunk has a flag (0 for free, 1 for busy) So when we try to give another shift to a worker, we can do binary comparison of workers daily availability with shift's time. Simple and easy to decide.

But C# long only allows to have up to 64 bit, and with开发者_如何学编程 the current set up I need at least 96 bits (24 hours * 60 minutes / 15 minutes per period). This representation must be memory friendly, as there will be about a million objects operated at a time.

Few other options i considered:

• String. Memory-hungry, not simple to implement bit-wise operations
• Array of bits. But as far as I know C# does not have bit type
• Array of unsigned integers. Each array represents only part of a day. The best I can think of

Any other suggestions??

Thanks in advance!

Have you looked at the BitArray class? It should be pretty much exactly what you're looking for.

Try following,

.Net 4 has inbuilt BigInteger type

http://msdn.microsoft.com/en-us/library/system.numerics.biginteger.aspx

.Net 2 project on code project http://www.codeproject.com/KB/cs/biginteger.

Another alternative, http://www.codeplex.com/IntX/

Unless you have millions of employees that all need to be scheduled at the same time, I'd be tempted to store your 96 booleans as a char array with 0 meaning "free" and 1 meaning "busy". Simple to index/access/update. The rest of the employees schedules can sit in their database rows on disk where you simply don't care about "96 megabytes".

If you can find a class which implements a bit array, you could use that. (You could code one easily, too). But does it really matter spacewise?

Frankly, if your organization really has a million employees to schedule, surely you can afford a machine which has space for a 96 mB array as well as the rest of your code?

The one good excuse I can see for using bit vectors has to do with execution time cost. If you scheduling algorithm essentially ANDs one employee bit vector against another looking for conflicts, and does that on large scale, bit vectors might reduce the computation time to do this by a factor of roughly 10 (use a two *long*s per employee to get your 96 bits). I'd wait till my algorithm worked before I worried about this.

You could use and array of bytes. I don't think any language supports an array of bits, as a byte is the smallest addressable piece of memory. Other options are an array of booleans, but each boolean I believe is stored as a byte anyway, so there would be wasted memory, but it might be easier to work with. It really depends on how many days you are going to work with. You could also just store the start and end of the shift and use other means to figure out if there are overlapping schedules. This would probably make the most sense, and be the easiest to debug.

BitArray has already been mentioned, it uses an array of ints much like you planned to do anyway. That also means that it adds an extra layer of indirection (and some extra bytes); it also does a lot of checking everywhere to make sure that eg the lengths of two bitarrays is the same when operating on them. So I would be careful with them. They're easy, but slower than necessary - the difference is especially big (compared to handling the array yourself) for smallish bitarrays.