Best way to store / retrieve bits C# [duplicate]

This question already has an answer here:

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

I am modifying an existing C# solution, wherein data is validated and status is stored as below:

a) A given record is validated against certain no. of conditions (say 5). Failed / passed status is represented by a bit value (0 - passed; 1 - failed) b) So, if a record failed for all 5 validations, value will be 11111. This will be converted to a decimal and stored in a DB.

Once again, this decimal value will be converted back to binary (using bitwise & operator) which will be used to show the passed / failed records.

The issue is, long datatype is used in C# to handle the decimal and 'decimal' datatype in SQL Server 2008 to store this decimal value. The max. value of long converted to binary can hold only upto 64 bits, so validation count is currently restricted to 64.

My requirement is to remove this limit to allow any no. of validations.

How do I store a large no. of bits and also retrieve them? Also, please keep in mind, this being an existing (.NET 2.0) solution, can't afford to upgrade / use any 3rd party libraries and changes must be minimum

Latest update

Yes, this solution seems to be OK from an application perspective, i.e. if only I (a.k.a the present solution) were to use only C#. However, the designers of the existing solution made things complicated by storing the binary value (11111 represents all 5 records failed, 10111 - all but 4th record failed, and so on...) converted into decimal in SQL Server DB. An SP takes this value to arrive at no. of records failed for e each validation.

OPEN sValidateCUR                        
 FETCH NEXT FROM sValidateCUR INTO @ValidationOID,@ValidationBit, @ValidationType            
 WHILE @@FETCH_STATUS = 0                        
 BEGIN                 
 -- Fetch the Error Record Count                
 SET @nBitVal = ABS(RPT.fGetPowerValue(@ValidationBit))  -- Validation bit is no. of a type of validation, say, e.g. 60. So 1st time when loop run, ValidationBit will be 0
select @ErrorRecordCount = COUNT(1) FROM 
 <<Error_Table_Where_Flags_are availble in decimal values>>
          WITH(NOLOCK) WHERE  ExpressionValidationFlags & CAST(CAST(@nBitVal AS VARCHAR(20)) AS Bigint) = CAST(@nBitVal AS VARCHAR(20)) -- For @ValidationBit = 3, @nBitVal = 2^3 = 8

Now, in application, using BitArray, I managed to stored the passed / failed records in BitArray, converted this to byte[] and stored in SQL Server as VARBINARY(100)... (the same column ExpressionValidationFlags, which was earlier BIGINT, is now VARBINARY and holds the byte array). However, to complete my changes, I need to modify the SP above.

Again, looking forward for help!!

Thanks

Why not use a specially designed class BitArray?

http://msdn.microsoft.com/query/dev11.query?appId=Dev11IDEF1&l=EN-US&k=k(System.Collections.BitArray);k(TargetFrameworkMoniker-.NETFramework,Version%3Dv4.5);k(DevLang-csharp)&rd=true

e.g.

  BitArray array = new BitArray(150); // <- up to 150 bits

  ...
  array[140] = true;  // <- set 140th bit 
  array[130] = false; // <- reset 130th bit 
  ...
  if (array[120]) {   // <- if 120th bit is set
    ...

There are several ways to go about this, based on the limitations of the database you are using.

If you are able to store byte arrays within the database, you can use the BitArray class. You can pass the constructor a byte array, use it to easily check and set each bit by index, and then use it's built in CopyTo method to copy it back out into a byte array.

Example:

byte[] statusBytes = yourDatabase.Get("passed_failed_bits");
BitArray statusBits = new BitArray(statusBytes);
...
statusBits[65] = false;
statusBits[66] = true;
...
statusBits.CopyTo(statusBytes, 0);
yourDatabase.Set("passed_failed_bits", statusBytes);

If the database is unable to deal with raw byte arrays, you can always encode the byte array as a hex string:

string hex = BitConverter.ToString(statusBytes);
hex.Replace("-","");

and then get it back into a byte array again:

int numberChars = hex.Length;
byte[] statusBytes= new byte[numberChars / 2];
for (int i = 0; i < numberChars; i += 2) {
    statusBytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
}

And if you can't even store strings, there are more creative ways to turn the byte array into multiple longs or doubles.

Also, if space efficiency is an issue, there are other, more efficient (but more complicated) ways to encode bytes as ascii text by using more of the character range without using control characters. You may also want to look into Run Length Encoding the byte array, if you're finding the data remains the same value for long stretches.

Hope this helps!

Why not use a string instead? You could put a very large number of characters in the database (use VARCHAR and not NVARCHAR since you control the input).

Using your example, if you had "11111", you could skip bitwise operations and just do things like this:

string myBits = "11111";
bool failedPosition0 = myBits[0] == '1';
bool failedPosition1 = myBits[1] == '1';
bool failedPosition2 = myBits[2] == '1';
bool failedPosition3 = myBits[3] == '1';
bool failedPosition4 = myBits[4] == '1';

来源：https://stackoverflow.com/questions/20650651/best-way-to-store-retrieve-bits-c-sharp

标签

bit-manipulation