C# 使用二进制 逻辑（与、或、非）位移运算 控制系统权限

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Grass.Authorize
{
/// <summary>
/// 二进制授权帮助类,最多支持 62 种不同权限，鉴权值最大为2的62次方（即：4611686018427387904）
/// </summary>
public class BinAuth
{
/// <summary>
/// 验证非负正整数是否为2的幂级
/// </summary>
/// <remarks></remarks>
/// <param name="n"></param>
/// <returns></returns>
public static bool IsBinPower(long n)
{
/*
判断是2的幂，1个数乘以2就是将该数左移1位，而2的0次幂为1，
所以2的n次幂（就是2的0次幂n次乘以2）就是将1左移n位，
这样我们知道如果一个数n是2的幂，则其只有首位为1，
其后若干个0，必然有n & (n - 1)为0。（在求1个数的二进制表示中1的个数的时候说过
，n&(n-1)去掉n的最后一个1）。因此，判断一个数n是否为2的幂，只需要判断n&(n-1)是否为0即可。
*/
return (n & (n - 1)) == 0;
}
/// <summary>
/// 获取2 的 x 次方值
/// </summary>
/// <param name="x">x 次方值</param>
/// <returns></returns>
public static long GetBinPower(int x)
{
return (long)System.Math.Pow(2, x);
}
/// <summary>
/// 将数值转为等值2进制数
/// </summary>
/// <param name="n"></param>
/// <returns></returns>
public static string GetBin(long n)
{
return Convert.ToString(n, 2);
}

/// <summary>
/// 生成鉴权码
/// </summary>
/// <param name="arr">权限值（2的幂级）</param>
/// <remarks>每个鉴权值执行或操作（code = code | n）</remarks>
/// <returns></returns>
public static long GenAuthCode(params long[] arr)
{
if (arr == null)
throw new Exception("权限值数组不允许为空,Grass.BinAuth.GenAuthCode()");
long code = 0;
arr.ToList().ForEach(x =>
{
if (!IsBinPower(x))
throw new Exception(string.Format("值 {0} 为无效的鉴权码不是2的幂级", x));
if (x< 0 ||x > 4611686018427387904)
throw new Exception(string.Format("鉴权值 {0} 应大于 0 小于 4611686018427387904", x));
code = code | x;
});
return code;
}
/// <summary>
/// 添加权限
/// </summary>
/// <param name="authCode">鉴权码</param>
/// <param name="auth">权限值（2的幂级）</param>
/// <remarks>code = authCode | auth</remarks>
/// <returns></returns>
public static long AddAuth(long authCode,long auth)
{
if (!IsBinPower(auth))
throw new Exception(string.Format("值 {0} 为无效的鉴权码不是2的幂级", auth));

if (auth < 0 || auth > 4611686018427387904)
throw new Exception(string.Format("鉴权值 {0} 应大于 0 小于 4611686018427387904", auth));

long code = authCode | auth;
return code;
}
/// <summary>
/// 移除权限
/// </summary>
/// <param name="authCode">鉴权码</param>
/// <param name="auth">权限值（2的幂级）</param>
/// <remarks>code = authCode & (~auth)</remarks>
/// <returns></returns>
public static long RemoveAuth(long authCode, long auth)
{
if (!IsBinPower(auth))
throw new Exception(string.Format("值 {0} 为无效的鉴权码不是2的幂级", auth));

if (auth < 0 || auth > 4611686018427387904)
throw new Exception(string.Format("鉴权值 {0} 应大于 0 小于 4611686018427387904", auth));

long code = authCode & (~auth);
return code;
}

/// <summary>
/// 验证权限
/// </summary>
/// <param name="authCode">鉴权码</param>
/// <param name="auth">权限值（2的幂级）</param>
/// <remarks>auth == (authCode & auth)</remarks>
/// <returns></returns>
public static bool IsHasAuth(long authCode, long auth)
{
if (!IsBinPower(auth))
throw new Exception(string.Format("值 {0} 为无效的鉴权码不是2的幂级", auth));

if (authCode <= 0 || auth<=0)
return false;

return auth == (authCode & auth);
}
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Grass.Authorize;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace TestGrass
{
    [TestClass]
    public class TestBinAuth
    {
        /// <summary>
        /// 验证非负正整数是否为 2 的幂级
        /// </summary>
        /// <remarks>
        /// 判断是2的幂，1个数乘以2就是将该数左移1位，而2的0次幂为1， 所以2的n次幂（就是2的0次幂n次乘以2）就是将1左移n位， 这样我们知道如果一个数n是2的幂，则其只有首位为1，其后若干个0，必然有n & (n - 1)为0。（在求1个数的二进制表示中1的个数的时候说过，n&(n-1)去掉n的最后一个1）。因此，判断一个数n是否为2的幂，只需要判断n&(n-1)是否为0即可。
        /// </remarks>
        /// <returns></returns>
        [TestMethod]
        public void TestIsBinPower()
        {
            string str = "";
            for (int i = 0; i < 64; i++)
            {
                long n = BinAuth.GetBinPower(i);
                str = BinAuth.GetBin(n);
                if (!BinAuth.IsBinPower(n))
                    Assert.IsTrue(false);
            }
            Assert.IsTrue(true);
        }

        /// <summary>
        /// 获取2 的 x 次方值
        /// </summary>
        /// <returns></returns>
        [TestMethod]
        public void TestGetBinPower()
        {
            long n = (long)Math.Pow(2, 50);
            string ns = BinAuth.GetBin(n);

            long m = BinAuth.GetBinPower(50);
            string ms = BinAuth.GetBin(m);
            Assert.IsTrue(n == m);
        }
        /// <summary>
        /// 将数值转为等值2进制数
        /// </summary>
        /// <returns></returns>
        [TestMethod]
        public void TestGetBin()
        {
            long n = (long)Math.Pow(2, 50);
            string s1 = BinAuth.GetBin(n);
            string s2 = Convert.ToString(n, 2);
            Assert.IsTrue(s1.Equals(s2));
        }

        /// <summary>
        /// 生成鉴权码
        /// </summary>
        /// <param name="arr">权限值（2的幂级）</param>
        /// <remarks>每个鉴权值执行或操作</remarks>
        /// <returns></returns>
        [TestMethod]
        public void TestGenAuthCode()
        {
            long authCode = 0;
            string binStr = "";
            List<long> codeList = new List<long>();
            for (int i = 1; i <= 62; i++)
            {
                codeList.Add((long)Math.Pow(2, i));
            }
            authCode = BinAuth.GenAuthCode(codeList.ToArray());
            binStr = BinAuth.GetBin(authCode); ;
            Assert.IsTrue(true);
        }
        /// <summary>
        /// 添加权限
        /// </summary>
        /// <remarks>code = authCode | auth</remarks>
        /// <returns></returns>
        [TestMethod]
        public void TestAddAuth()
        {
            long authCode = 0;
            string binStr = "";
            for (int i = 1; i <= 62; i++)
            {
                long x = BinAuth.GetBinPower(i);
                authCode = BinAuth.AddAuth(authCode, x);
                binStr = BinAuth.GetBin(authCode);
            }
            binStr = BinAuth.GetBin(authCode);
            Assert.IsTrue(true);
        }
        /// <summary>
        /// 移除权限
        /// </summary>
        /// <remarks>code = authCode & (~auth)</remarks>
        /// <returns></returns>
        [TestMethod]
        public void TestRemoveAuth()
        {
            long authCode = 9223372036854775806;//表示最大权限值
            string binStr = "";
            for (int i = 1; i <= 62; i++)
            {
                long x = BinAuth.GetBinPower(i);
                authCode = BinAuth.RemoveAuth(authCode, x);
                binStr = BinAuth.GetBin(authCode);
            }
            binStr = BinAuth.GetBin(authCode);
            Assert.IsTrue(true);

        }

        /// <summary>
        /// 验证权限
        /// </summary>
        /// <returns></returns>
        [TestMethod]
        public void TestIsHasAuth()
        {
            long[] arr = {1, 2, 4, 8, 16, 32, 64};
            long authCode = BinAuth.GenAuthCode(arr);
            Assert.IsTrue(BinAuth.IsHasAuth(authCode, 1));
            Assert.IsTrue(BinAuth.IsHasAuth(authCode, 2));
            Assert.IsTrue(BinAuth.IsHasAuth(authCode, 4));
            Assert.IsTrue(BinAuth.IsHasAuth(authCode, 8));
            Assert.IsTrue(BinAuth.IsHasAuth(authCode, 16));
            Assert.IsTrue(BinAuth.IsHasAuth(authCode, 32));
            Assert.IsTrue(BinAuth.IsHasAuth(authCode, 64));

            Assert.IsFalse(BinAuth.IsHasAuth(-1, 0));
            Assert.IsFalse(BinAuth.IsHasAuth(0, 0));
            Assert.IsFalse(BinAuth.IsHasAuth(authCode, 128));
            Assert.IsFalse(BinAuth.IsHasAuth(authCode, 256));
        }
    }
}