[代码共享]子网划分器

近来做毕业设计,涉及到一个对A B C 类网的划分工具。
具体算法，并不精巧，用的是空间换时间的方法 ，首先将所有的子网掩码计算出来，然后再查找比较

     public   enum  IPClassEnum: int
     ... {
        ClassA = 24,
        ClassB = 16,
        ClassC = 8,
        Special=32
    }

24 ， 16 ， 8 是指主机位有多少位

     public   class  MaskInfo
     ... {
        public MaskInfo(UInt32 maskValue , int subNetCount , int hostPerSubNet)
        ...{
            UInt32 A, B, C, D;//分别表示IP的四段
            // 通过移位运算来取得取得IP的四段
            A = (UInt32)(maskValue >> 24);
            B = (UInt32)(maskValue << 8) >> 24;
            C = (UInt32)(maskValue << 16) >> 24;
            D = (UInt32)(maskValue << 24) >> 24;
            this._Mask = string.Format("{0}.{1}.{2}.{3}", A, B, C, D);
            this._SubNetCount = subNetCount;
            this._hostPerSubNet = hostPerSubNet;
        }    
        private string _Mask;
        public string Mask
        ...{
            get ...{ return _Mask; }
        }
        private int _SubNetCount;
        public int SubNetCount
        ...{
            get ...{ return _SubNetCount; }
        }
        private int _hostPerSubNet;
        public int HostPerSubNet
        ...{
            get ...{ return _hostPerSubNet; }
        }
    }

这是用于描述每一个子网掩码的情况

public   class  IPClass
     ... {
        public static IList<MaskInfo> ClassA = new List<MaskInfo>();
        public static IList<MaskInfo> ClassB = new List<MaskInfo>();
        public static IList<MaskInfo> ClassC = new List<MaskInfo>();

        public static readonly IPClass Instance = new IPClass();

        private IPClass()
        ...{
            InitMaskSet(IPClassEnum.ClassA);
            InitMaskSet(IPClassEnum.ClassB);
            InitMaskSet(IPClassEnum.ClassC);
        }
        
        封装计算子网Mask#region 封装计算子网Mask
        private void SetMaskSet( UInt32 mask , int zeroStart , int zeroEnd , IList<MaskInfo> maskSet)
        ...{
            UInt32 defaultMask = mask;
            int hostCount = 0;
            int netBits = 0;
            for (int i = zeroStart; i >= zeroEnd; i--)
            ...{
                netBits = zeroStart - i;
                defaultMask = (uint)(defaultMask | (1 << i));
                hostCount = (int)Math.Pow(2, i) - 2;
                maskSet.Add(new MaskInfo(defaultMask, (int)Math.Pow(2, netBits), hostCount));
            }
        }
        private void InitMaskSet(IPClassEnum ipc)
        ...{
            UInt32 defaultMask = (UInt32.MaxValue >> (int)ipc) << (int)ipc;
            int zeroStart = (int)ipc;
            int zeroEnd = 1;
            this.SetMaskSet(defaultMask, zeroStart, zeroEnd, GetIpClassSetFromIpClassEnum(ipc));
        }
        private IList<MaskInfo> GetIpClassSetFromIpClassEnum(IPClassEnum ipc)
        ...{
            switch (ipc)
            ...{
                case IPClassEnum.ClassA:
                    ...{
                        return ClassA;
                    }
                case IPClassEnum.ClassB:
                    ...{
                        return ClassB;
                    }
                case IPClassEnum.ClassC:
                    ...{
                        return ClassC;
                    }
                default:
                    ...{
                        return null;
                    }
            }
        }
        #endregion

        public IList<MaskInfo> GetMask(IPClassEnum ipc, int host, int subnet)
        ...{
            IList<MaskInfo> selectedClass = GetIpClassSetFromIpClassEnum(ipc);
            IList<MaskInfo> rtnValue = new List<MaskInfo>();
            for (int i = 0; i < selectedClass.Count; i++)
            ...{
                if (selectedClass[i].HostPerSubNet >= host || host == 0)
                ...{
                    if (selectedClass[i].SubNetCount >= subnet || subnet == 0)
                    ...{
                        rtnValue.Add(selectedClass[i]);
                    }
                }
            }
            return rtnValue;
        }
    }

这是具体的运算求解类