如果我有一个子网掩码255.255.255.0和一个 IP 地址192.168.1.5，是否有一种简单的方法可以确定该子网内所有可能的 IP 地址？
在这种情况下：
192.168.1.1
192.168.1.2
192.168.1.3
192.168.1.4
...
...
192.168.1.252
192.168.1.253
192.168.1.254
192.168.1.255
到目前为止，我发现的只是重载的 .net 库。没有任何本地方法可以使用默认命名空间解决这个问题吗？
10 分钟的编码，未经过全面测试：
class IPSegment {
private UInt32 _ip;
private UInt32 _mask;
public IPSegment(string ip, string mask) {
_ip = ip.ParseIp();
_mask = mask.ParseIp();
}
public UInt32 NumberOfHosts {
get { return ~_mask+1; }
}
public UInt32 NetworkAddress {
get { return _ip & _mask; }
}
public UInt32 BroadcastAddress {
get { return NetworkAddress + ~_mask; }
}
public IEnumerable<UInt32> Hosts(){
for (var host = NetworkAddress+1; host < BroadcastAddress; host++) {
yield return host;
}
}
}
public static class IpHelpers {
public static string ToIpString(this UInt32 value) {
var bitmask = 0xff000000;
var parts = new string[4];
for (var i = 0; i < 4; i++) {
var masked = (value & bitmask) >> ((3-i)*8);
bitmask >>= 8;
parts[i] = masked.ToString(CultureInfo.InvariantCulture);
}
return String.Join(".", parts);
}
public static UInt32 ParseIp(this string ipAddress) {
var splitted = ipAddress.Split('.');
UInt32 ip = 0;
for (var i = 0; i < 4; i++) {
ip = (ip << 8) + UInt32.Parse(splitted[i]);
}
return ip;
}
}
用法：
static void Main(string[] args) {
IPSegment ip = new IPSegment("192.168.1.1","255.255.255.248");
Console.WriteLine(ip.NumberOfHosts);
Console.WriteLine(ip.NetworkAddress.ToIpString());
Console.WriteLine(ip.BroadcastAddress.ToIpString());
Console.WriteLine("===");
foreach (var host in ip.Hosts()) {
Console.WriteLine(host.ToIpString());
}
Console.ReadLine();
}
要确定地址范围，请执行以下步骤：
1）获取您的子网掩码（此处为 255.255.255.0）并将其转换为二进制：
11111111.11111111.11111111.00000000
( 8 + 8 + 8 + 0 = 24 -> So you can write your ip adresse like this : 192.168.1.x/24 because you are in a /24 network)
2）您在 /24 网络中有 256-2=254 个可用的主机 IP 地址（一个用于网络地址（您范围内的第一个），另一个用于广播地址（您范围内的最后一个）） .
3) 要获取您的范围，只需获取您的网络地址（根据您的子网掩码的第一个 ip 地址）并获取接下来的 255 个 IP 地址，您将拥有您的范围。
您的网络地址：
在二进制中，最后一个八位字节必须为 null ：
xxxxxxxx.xxxxxxxx.xxxxxxxx.00000000
您的广播地址：
在二进制中，最后一个八位字节必须等于 1：
xxxxxxxx.xxxxxxxx.xxxxxxxx.11111111
这里你的 ip 地址是 192.168.1.5。在二进制中，我们得到：
11000000.10101000.00000000.00000101
第一个可用IP地址：192.168.1.1
最后可用IP地址：192.168.1.254
希望你喜欢阅读糟糕的英语。如果你有任何问题，请告诉我，洛里斯
是的，将所有内容都转换为 32 位表示（假设 IPv4）。如果您的掩码是 M 而 ip 是 IP，那么您的 ip 范围是 (M&IP)+1,(M&IP)+2,...,(M&IP)+(~M)-1。其中 & 是按位与，而 ~ 是按位非。
要将事物转换为 32 位表示，ip abcd 中的每个点都是一个 8 位数字。
要使用，只需：
string[] range GetIpRange("100.68.18.218", "255.255.255.252",true)`;
最后一个参数
true是过滤第一个和最后一个IP
来得到完整的答案，把它设置为false
它将返回第一个和最后一个可用的 IP。
所有代码解释如下：
/// <summary>
/// IPAddress to UInteger
/// </summary>
/// <param name="ipAddress"></param>
/// <returns></returns>
public static uint IPToUInt(this string ipAddress)
{
if (string.IsNullOrEmpty(ipAddress))
return 0;
if (IPAddress.TryParse(ipAddress, out IPAddress ip))
{
var bytes = ip.GetAddressBytes();
Array.Reverse(bytes);
return BitConverter.ToUInt32(bytes, 0);
}
else
return 0;
}
/// <summary>
/// IP in Uinteger to string
/// </summary>
/// <param name="ipUInt"></param>
/// <returns></returns>
public static string IPToString(this uint ipUInt)
{
return ToIPAddress(ipUInt).ToString();
}
/// <summary>
/// IP in Uinteger to IPAddress
/// </summary>
/// <param name="ipUInt"></param>
/// <returns></returns>
public static IPAddress ToIPAddress(this uint ipUInt)
{
var bytes = BitConverter.GetBytes(ipUInt);
Array.Reverse(bytes);
return new IPAddress(bytes);
}
/// <summary>
/// First and Last IPv4 from IP + Mask
/// </summary>
/// <param name="ipv4"></param>
/// <param name="mask">Accepts CIDR or IP. Example 255.255.255.0 or 24</param>
/// <param name="filterUsable">Removes not usable IPs from Range</param>
/// <returns></returns>
/// <remarks>
/// If ´filterUsable=false´ first IP is not usable and last is reserved for broadcast.
/// </remarks>
public static string[] GetIpRange(string ipv4, string mask, bool filterUsable)
{
uint[] uiIpRange = GetIpUintRange(ipv4, mask, filterUsable);
return Array.ConvertAll(uiIpRange, x => IPToString(x));
}
/// <summary>
/// First and Last IPv4 + Mask.
/// </summary>
/// <param name="ipv4"></param>
/// <param name="mask">Accepts CIDR or IP. Example 255.255.255.0 or 24</param>
/// <param name="filterUsable">Removes not usable IPs from Range</param>
/// <returns></returns>
/// <remarks>
/// First IP is not usable and last is reserverd for broadcast.
/// Can use all IPs in between
/// </remarks>
public static uint[] GetIpUintRange(string ipv4, string mask, bool filterUsable)
{
uint sub;
//check if mask is CIDR Notation
if (mask.Contains(".")) {
sub = IPToUInt(mask);
}
else
{
sub = ~(0xffffffff >> Convert.ToInt32(mask));
}
uint ip2 = IPToUInt(ipv4);
uint first = ip2 & sub;
uint last = first | (0xffffffff & ~sub);
if (filterUsable)
{
first += 1;
last -= 1;
}
return new uint[] { first, last };
}
好决定。不要为此使用额外的库。这很简单。我就是这样做的：
public static uint[] GetIpRange(string ip, IPAddress subnet)
{
uint ip2 = Utils.IPv4ToUInt(ip);
uint sub = Utils.IPv4ToUInt(subnet);
uint first = ip2 & sub;
uint last = first | (0xffffffff & ~sub);
return new uint[] { first, last };
}
注意：
您需要做更多的工作将 IP 转换为 uint 并返回（应该很容易）。然后，您可以在first和last之间使用简单的 for 循环迭代所有 IP 。
像这样的东西（未经测试）：
byte[] bytes = subnet.GetAddressBytes();
uint sub = (uint)((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]);
IPAddress ip1 = IPAddress.Parse(ip);
bytes = ip1.GetAddressBytes();
uint ip2 = (uint)((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]);