C＃を使用してバイト配列のビットを設定する

Question

私は32バイトのバイト配列を持ち、各バイト（0から3）の最初の4ビットは1から128までの数字のセットまたはセットされていない状態を表します。たとえば、If私は3を与えられました、私はビット2を配列の最初のバイトにセットする必要があります。私に数字9が与えられていれば、配列の3番目のバイトのビット0を設定する必要があります。私が持っている問題は、C＃でこれを行う賢明な方法を見つけることです。私はそれを数学的に行う簡単な方法がなければならないと確信していますが、これまで方法を見つけることができませんでした。私はこの頭の上で私の頭を傷つけますが、誰かが助言を与えることができるかどうかは分かりました。与えられた回答に基づいて

---------更新-------------------

、私は次の関数を生産しています。これはまさに私が必要とするものです。私は私の質問で私が必要としたことを明確にしていないかもしれませんが、適切なコードを見つけるために十分な助言が私に与えられました。 bytesがあなたのバイト配列である

// outputNumber = number passed into this function 

byte[] bytes = new byte[32]; 

int bit = (outputNumber - 1) % 4; 

byte byteSetting = (byte)(1 << bit); 

bytes[(outputNumber - 1)/4] |= byteSetting; 

Answer 1

int byt = bitNumber/4; // You could do byt = bitNumber >> 2 
int bit = bitNumber % 4; // You could do bit = bitNumber & 3 

bytes[byt] |= (byte)(1 << bit); 

。

bytes[byt] &= (byte)(byte.MaxValue^(1 << bit)); 

バイトの値読み取るには：それをリセットするには

var res = bytes[byt] & (byte)(1 << bit) 

を（あなたが興味を持っている場合は、^はXOR演算子である）

Answer 2

あなたが設定することができます配列の各バイトのビットは次のようになります。

array[2] |= (byte)(1<<3); // set bit #4/index 3 in array element #3/index 2 

あなたは、このようにビットをクリアすることができます

array[2] &= unchecked((byte)(~(1<<3))); // clear the same bit we set previously 

Answer 3

は似たような必要。 64ビットシステムでは、バイトの代わりにulongs（32ビット - > uint）を使用します。パフォーマンスの違いはかなり重要です。

public struct BitField { 

    private ulong[] _Values; 

    private BitField(ulong[] values) { 
     _Values = values; 
    } 

    public static BitField New() { 
     return new BitField(new ulong[] { 0ul, 0ul }); 
    } 

    public BitField Clone() { 
     return new BitField(new ulong[] { _Values[0], _Values[1] }); 
    } 

    public void Clear() { 
     _Values[0] = ulong.MinValue; 
     _Values[1] = ulong.MinValue; 
    } 

    public void SetAll() { 
     _Values[0] = ulong.MaxValue; 
     _Values[1] = ulong.MaxValue; 
    } 

    public void AND_Combine(BitField bitField) { 

     _Values[0] &= bitField._Values[0]; 
     _Values[1] &= bitField._Values[1]; 
    } 

    public void OR_Combine(BitField bitField) { 

     _Values[0] |= bitField._Values[0]; 
     _Values[1] |= bitField._Values[1]; 
    } 

    public bool Intersects(BitField bitField) { 

     if ((_Values[0] & bitField._Values[0]) > 0) { 
      return true; 
     } 
     else { 
      if ((_Values[1] & bitField._Values[1]) > 0) { 
       return true; 
      } 
      else { 
       return false;         
      } 
     } 
    } 

    public bool this[int index] { 
     get { 
      if (index > 127 || index < 0) { 
       return false; 
      } 
      int item = index >> 6; 
      int bit = index % 64; 

      ulong compare = 1ul << bit; 
      return ((_Values[item] & compare) == compare); 
     } 
     set { 
      if (index >= 0 || index < 128) { 
       int item = index >> 6; 
       int bit = index % 64; 
       ulong compare = 1ul << bit; 

       if (value) { 
        _Values[item] |= compare; 
       } 
       else { 
        _Values[item] &= ~compare; 
       } 
      } 
     } 
    } 
}