private static IPAddress LoadIPAddress() { var interfaces = GetNetworkInterfaces(); Func <IEnumerable <NetworkInterfaceData>, IEnumerable <IPAddress> > getAddresses = interfaceList => interfaceList.SelectMany(x => x.Addresses) .OrderBy(x => x.AddressFamily != AddressFamily.InterNetwork); // Prefer IPv4 until working IPv6 detection is reliable // Even though the docs say that NetworkIntereface.Type only returns a subset of these types, I've seen some others // (for example Tunnel) in the wild, so let's just list all acceptable types. var preferedTypes = new NetworkInterfaceType[] { NetworkInterfaceType.Ethernet, NetworkInterfaceType.FastEthernetFx, NetworkInterfaceType.FastEthernetT, NetworkInterfaceType.GigabitEthernet, }; var lanAddresses = getAddresses(interfaces.Where(x => preferedTypes.Contains(x.Type))); if (lanAddresses.Any()) { return(lanAddresses.First()); } var addresses = getAddresses(interfaces); if (addresses.Any(x => !_localhostNames.Contains(x.ToString()))) { return(addresses.First(x => !_localhostNames.Contains(x.ToString()))); } if (addresses.Any()) { return(addresses.First()); } return(IPAddress.Parse("127.0.0.1")); }
/* Returns an array of valid network interfaces. ** Used to create a NetworkMonitor object for ** all up and running network interfaces. ** Valid interfaces are those that are not a ** loopback or tunnel interface/adapter and ** are up and running and not a virtual ethernet ** interface/adapter. */ private static NetworkInterface[] GetInterfaces() { // Unallowed interface types. var invalidInterfaces = new NetworkInterfaceType[2] { NetworkInterfaceType.Loopback, NetworkInterfaceType.Tunnel }; // Store all interfaces. var interfaces = NetworkInterface.GetAllNetworkInterfaces(); // Stores all valid interfaces. var validInterfaces = new List <NetworkInterface>(); foreach (var intf in interfaces) { if (!(invalidInterfaces.Contains(intf.NetworkInterfaceType))) { if (OperationalStatus.Up == intf.OperationalStatus && !(intf.Name.StartsWith("vEthernet"))) { validInterfaces.Add(intf); } /* Check if running and not virtual ethernet. */ } /* Check for valid interface type. */ } /* Loop through available interfaces. */ return(validInterfaces.ToArray()); }
/// <summary> /// Inspects the local system for local (non-routable) IPv4 addresses. /// </summary> /// <returns>An IEnumerable of discovered local addresses.</returns> internal static IEnumerable <string> GetLocalIpAddresses() { List <string> addressList = new List <string>(); NetworkInterfaceType[] allowableTypes = new NetworkInterfaceType[] { NetworkInterfaceType.Ethernet, NetworkInterfaceType.Wireless80211, NetworkInterfaceType.GigabitEthernet }; Tuple <IPAddress, IPAddress>[] privateRanges = new Tuple <IPAddress, IPAddress>[] { Tuple.Create(IPAddress.Parse("10.0.0.0"), IPAddress.Parse("255.0.0.0")), Tuple.Create(IPAddress.Parse("172.16.0.0"), IPAddress.Parse("255.240.0.0")), Tuple.Create(IPAddress.Parse("192.168.0.0"), IPAddress.Parse("255.255.0.0")), }; IEnumerable <NetworkInterface> interfaces = NetworkInterface.GetAllNetworkInterfaces() .Where(i => i.OperationalStatus == OperationalStatus.Up) .Where(i => allowableTypes.Contains(i.NetworkInterfaceType)); foreach (NetworkInterface iface in interfaces) { var ifAddressInfo = iface.GetIPProperties().UnicastAddresses.Where(i => i.Address.AddressFamily == AddressFamily.InterNetwork); foreach (UnicastIPAddressInformation ifAddress in ifAddressInfo) { IPAddress address = ifAddress.Address; foreach (var range in privateRanges) { if (address.GetNetworkAddress(range.Item2).Equals(range.Item1)) { addressList.Add(address.ToString()); } } } } return(addressList); }
public static bool IsNetworkAvailable(string excludeIps = null) { // If no adapters available then return false; if (!NetworkInterface.GetIsNetworkAvailable()) { return(false); } var nics = NetworkInterface.GetAllNetworkInterfaces(); var badTypes = new NetworkInterfaceType[] { NetworkInterfaceType.Tunnel, NetworkInterfaceType.Loopback }; var goodFamily = new AddressFamily[] { AddressFamily.InterNetwork, AddressFamily.InterNetworkV6 }; foreach (var nic in nics) { // If network interface is not up then skip. if (nic.OperationalStatus != OperationalStatus.Up) { continue; } // If interface type is invalid then skip. if (badTypes.Contains(nic.NetworkInterfaceType)) { continue; } // Get IP4 and IP6 statistics. //var stats = nic.GetIPStatistics(); // If no data send or received then skip. //if (stats.BytesSent == 0 || stats.BytesReceived == 0) // continue; // Loop trough IP address properties. var properties = nic.GetIPProperties(); for (var a = 0; a < properties.UnicastAddresses.Count; a++) { var address = properties.UnicastAddresses[a].Address; // If not IP4 or IP6 then continue. if (!goodFamily.Contains(address.AddressFamily)) { continue; } // If loop back then continue. if (IPAddress.IsLoopback(address)) { continue; } // If excluded IP then continue. if (excludeIps != null && IsExcludedIp(address.ToString(), excludeIps)) { continue; } // Address passed availability. return(true); } } return(false); }
/// <summary> /// This method is time consuming and would freeze application if you run it on main thread. /// </summary> public static NetworkInfo CheckNetwork(string excludeIps = null) { var info = new NetworkInfo(); var nicsList = new List <String>(); var nics = NetworkInterface.GetAllNetworkInterfaces(); var ips = new List <KeyValuePair <string, int> >(); var badTypes = new NetworkInterfaceType[] { NetworkInterfaceType.Tunnel, NetworkInterfaceType.Loopback }; for (int i = 0; i < nics.Length; i++) { var ni = nics[i]; if (badTypes.Contains(ni.NetworkInterfaceType)) { continue; } var nicsSb = new StringBuilder(); nicsSb.AppendFormat(" Name = {0}, Status = {1}", ni.Name, ni.OperationalStatus); var sb = new StringBuilder(); var properties = ni.GetIPProperties(); FillAdapter(sb, ni); info.NicInfo.Add(new KeyValue(ni.Description, sb.ToString())); if (ni.OperationalStatus == OperationalStatus.Up) { var desc = ni.Description; // If state is still off then... if (!info.IsMobileNicUp) { info.IsMobileNicUp = desc.Contains("HSPA Network"); } // If state is still off then... if (!info.IsWirelessNicUp) { info.IsWirelessNicUp = desc.Contains("802.11") || desc.Contains("802.11"); } // Loop trough IP address properties. for (var a = 0; a < properties.UnicastAddresses.Count; a++) { var address = properties.UnicastAddresses[a].Address; // If not IP4 version then skip. if (address.AddressFamily != AddressFamily.InterNetwork) { continue; } // If loop-back then skip. if (IPAddress.IsLoopback(address)) { continue; } nicsSb.AppendFormat(", Address = {0}", address); // If excluded then skip. if (excludeIps != null && IsExcludedIp(address.ToString(), excludeIps)) { continue; } // Normal IP4 address was found. info.IsNetworkAvailable = true; // More configuration = higher priority of IP address. var priority = properties.GatewayAddresses.Count + properties.DnsAddresses.Count + properties.DhcpServerAddresses.Count + properties.WinsServersAddresses.Count; ips.Add(new KeyValuePair <string, int>(address.ToString(), priority)); } } nicsList.Add(nicsSb.ToString()); } info.CurrentNicks = string.Join("\r\n", nicsList); var ipAddress = ips.OrderByDescending(x => x.Value).Select(x => x.Key).FirstOrDefault(); if (ipAddress != null) { info.LocalIpAddress = ipAddress; } return(info); }
private static IPAddress LoadIPAddress() { var interfaces = GetNetworkInterfaces(); Func<IEnumerable<NetworkInterfaceData>, IEnumerable<IPAddress>> getAddresses = interfaceList => interfaceList.SelectMany(x => x.Addresses) .OrderBy(x => x.AddressFamily != AddressFamily.InterNetwork); // Prefer IPv4 until working IPv6 detection is reliable // Even though the docs say that NetworkIntereface.Type only returns a subset of these types, I've seen some others // (for example Tunnel) in the wild, so let's just list all acceptable types. var preferedTypes = new NetworkInterfaceType[] { NetworkInterfaceType.Ethernet, NetworkInterfaceType.FastEthernetFx, NetworkInterfaceType.FastEthernetT, NetworkInterfaceType.GigabitEthernet, }; var lanAddresses = getAddresses(interfaces.Where(x => preferedTypes.Contains(x.Type))); if (lanAddresses.Any()) return lanAddresses.First(); var addresses = getAddresses(interfaces); if (addresses.Any(x => !_localhostNames.Contains(x.ToString()))) return addresses.First(x => !_localhostNames.Contains(x.ToString())); if (addresses.Any()) return addresses.First(); return IPAddress.Parse("127.0.0.1"); }