C# 中使用位运算（与、或、非 & | ^）进行数据校验

前言：

　　要学会位运算，首先要清楚什么是位运算？程序中的所有内容在计算机内存中都是以二进制的形式储存的（即：0或1），位运算就是直接对在内存中的二进制数的每位进行运算操作

知识了解：

　　在C#中可以对整型运算对象按位进行逻辑运算。按位进行逻辑运算的意义是：依次取被运算对象的每个位，进行逻辑运算，每个位的逻辑运算结果是结果值的每个位。C#支持的位逻辑运算符如表2.9所示。

运算符号	意义	运算对象类型	运算结果类型	对象数	实例
~	位逻辑非运算	整型，字符型	整型	1	~a
&	位逻辑与运算			2	a & b
|	位逻辑或运算			2	a | b
^	位逻辑异或运算			2	a ^ b
<<	位左移运算			2	a<<4
>>	位右移运算			2	a>>2

 

1、位逻辑非运算

位逻辑非运算是单目的，只有一个运算对象。位逻辑非运算按位对运算对象的值进行非运算，即：如果某一位等于0，就将其转变为1；如果某一位等于1，就将其转变为0。

比如，对二进制的10010001进行位逻辑非运算，结果等于01101110，用十进制表示就是：

~145等于110；对二进制的01010101进行位逻辑非运算，结果等于10101010。用十进制表示就是~85等于176。

 

2、位逻辑与运算

位逻辑与运算将两个运算对象按位进行与运算。与运算的规则：1与1等于1，1与0等于0。

比如：10010001（二进制）&11110000等于10010000（二进制）。

 

3、位逻辑或运算

位逻辑或运算将两个运算对象按位进行或运算。或运算的规则是：1或1等1，1或0等于1，

0或0等于0。比如10010001（二进制）| 11110000（二进制）等于11110001（二进制）。

 

4、位逻辑异或运算

位逻辑异或运算将两个运算对象按位进行异或运算。异或运算的规则是：1异或1等于0，

1异或0等于1，0异或0等于0。即：相同得0，相异得1。

比如：10010001（二进制）^11110000（二进制）等于01100001（二进制）。

 

5、位左移运算

位左移运算将整个数按位左移若干位，左移后空出的部分0。比如：8位的byte型变量

byte a=0x65(即二进制的01100101),将其左移3位：a<<3的结果是0x27(即二进制的00101000)。

 

将第一个操作数向左移动第二个操作数指定的位数，空出的位置补0。
  左移相当于乘. 左移一位相当于乘2;左移两位相当于乘4;左移三位相当于乘8。

  x<<1= x*2 
  x<<2= x*4 
  x<<3= x*8 
  x<<4= x*16

6、位右移运算

　　位右移运算将整个数按位右移若干位，右移后空出的部分填0。比如：8位的byte型变量

Byte a=0x65(既（二进制的01100101）)将其右移3位：a>>3的结果是0x0c(二进制00001100)。

将第一个操作数向右移动第二个操作数所指定的位数，空出的位置补0。

  右移相当于整除. 右移一位相当于除以2;右移两位相当于除以4;右移三位相当于除以8。

  x>>1= x/2 
  x>>2= x/4 
  x>>3= x/8 
  x>>4=x/16

使用：

位运算帮助类

using System;
using System.Linq;

namespace BitwiseDemo.Utilities
{
    /// <summary>
    /// 位运算校验帮助类
    /// </summary>
    public class BitwiseOperationHelper
    {
        /// <summary>
        /// 验证整数是否为2的幂级
        /// </summary>
        /// <remarks></remarks>
        /// <param name="n"></param>
        /// <returns></returns>
        public static bool ValidateValuePower(long n)
        {
            return (n & (n - 1)) == 0;
        }

        /// <summary>
        /// 获取2的n次方值
        /// </summary>
        /// <param name="n">n次方值</param>
        /// <returns></returns>
        public static long GetValuePower(int n)
        {
            return (long)System.Math.Pow(2, n);
        }
        /// <summary>
        /// 获取二进制数
        /// </summary>
        /// <param name="n"></param>
        /// <returns></returns>
        public static string GetBinaryValue(long n)
        {
            return Convert.ToString(n, 2);
        }

        /// <summary>
        /// 生成位运算数值
        /// </summary>
        /// <param name="list">权限值</param>
        /// <remarks>每个值执行或操作（value = value | n）</remarks>
        /// <returns></returns>
        public static long GenerateBitwise(params long[] list)
        {
            if (list == null)
                throw new Exception("值数组不允许为空");
            long value = 0;
            list.ToList().ForEach(n =>
            {
                if (!ValidateValuePower(n))
                    throw new Exception($"值 {n} 为无效的值，不是2的幂级");
                if (n < 0 || n > 4611686018427387904)
                    throw new Exception($"鉴权值 {n} 应大于 0 小于 4611686018427387904");
                value |= n;
            });
            return value;
        }
        /// <summary>
        /// 添加位值
        /// </summary>
        /// <param name="oldValue">原位数值</param>
        /// <param name="value">新加入的位值</param>
        /// <remarks>value = oldValue | newValue</remarks>
        /// <returns></returns>
        public static long AddBitwise(long oldValue, long value)
        {
            if (!ValidateValuePower(value))
                throw new Exception($"值 {value} 为无效的值，不是2的幂级");

            if (value < 0 || value > 4611686018427387904)
                throw new Exception($"值 {value} 应大于 0 小于 4611686018427387904");
            long returnValue = oldValue | value;
            return returnValue;
        }
        /// <summary>
        /// 移除位值
        /// </summary>
        /// <param name="oldValue">鉴权码</param>
        /// <param name="value">权限值（2的幂级）</param>
        /// <remarks>code = authCode & (~auth)</remarks>
        /// <returns></returns>
        public static long RemoveBitwise(long oldValue, long value)
        {
            if (!ValidateValuePower(value))
                throw new Exception($"值 {value} 无效");

            if (value < 0 || value > 4611686018427387904)
                throw new Exception($"值 {value} 应在 0 与 4611686018427387904 之间");

            long returnValue = oldValue & (~value);
            return returnValue;
        }

        /// <summary>
        /// 验证位值是否存在
        /// </summary>
        /// <param name="oldValue">原位值</param>
        /// <param name="value">值（2的幂级）</param>
        /// <remarks>value == (oldValue & value)</remarks>
        /// <returns></returns>
        public static bool ValidateBitwise(long oldValue, long value)
        {
            if (!ValidateValuePower(value))
                throw new Exception($"值 {value} 为无效的值");

            if (oldValue <= 0 || value <= 0)
                return false;

            return value == (oldValue & value);
        }
    }
}

 

示例：

        public void ValidateBitwise()
        {
            #region 测试位运算
            var validate = BitwiseOperationHelper.ValidateValuePower(3);
            Console.WriteLine($"validate:{validate}");

            //获取枚举值的幂次方
            var valuePower = BitwiseOperationHelper.GetValuePower((int)UserRight.Add);
            Console.WriteLine($"valuePower:{valuePower}");

            //获取枚举的二进制数
            var binary = BitwiseOperationHelper.GetBinaryValue(2);
            Console.WriteLine($"binary:{binary}");

            var binaryValue = BitwiseOperationHelper.GenerateBitwise(new long[] { (int)UserRight.Add, (int)UserRight.Update, (int)UserRight.View });
            var f = BitwiseOperationHelper.ValidateBitwise(binaryValue, (int)UserRight.Delete);
            var t = BitwiseOperationHelper.ValidateBitwise(binaryValue, (int)UserRight.Update);
            Console.WriteLine($"f:{f},t:{t}");
            #endregion
        }

使用到的枚举

public enum UserRight
    {
        Add = 1 << 0,
        Update = 1 << 1,
        View = 1 << 2,
        Delete = 1 << 3
    }

　　

结语：

　　善于总结，才能进步更快