C# code to get IP address

using System;
using System.Linq;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;

namespace IPAddressExample
{
	class Program
	{
		static void Main(string[] args)
		{
			Console.WriteLine(Methods.GetIp("192.168.1.1"));
			Console.ReadLine();
		}
	}

	public static class Methods
	{
		/// <summary>Retrieves an IP address from the local addresslist of the instantiator</summary>
		public static IPAddress GetIp(string gateway = "")
		{
			IPAddress m_gateway = new IPAddress(0);
			return IPAddress.TryParse(gateway, out m_gateway) ? GetIp(m_gateway) : null;
		}

		/// <summary>Retrieves an IP address from the local addresslist of the instantiator</summary>
		public static IPAddress GetIp(IPAddress gateway = null)
		{
			try
			{
				var m_lprops = IPGlobalProperties.GetIPGlobalProperties();
				var m_address = new IPAddress(0);
				IPAddress m_gateway = new IPAddress(0);
				if (gateway != null)
					m_gateway = gateway;

				// If there are no local IP global properties, return a null value.
				if (m_lprops == null)
				{
					Console.WriteLine("There are no local ip global properties.");
					return null;
				}

				// If no network connection is available, return a null value.
				if (!NetworkInterface.GetIsNetworkAvailable())
				{
					Console.WriteLine("There are no active network connections available.");
					return null;
				}

				// If a network connection is available (marked as up and is not a loopback or tunnel interface), try to return the IPAddress object associated with the network connection.
				var m_adapters = NetworkInterface.GetAllNetworkInterfaces();

				// If there are no network connections, return a null value.
				if (m_adapters == null || m_adapters.Count() < 1)
				{
					Console.WriteLine("There are no network connections available.");
					return null;
				}

				foreach (var m_adapter in m_adapters)
				{
					// Filter to exclude network interfaces that are not up [it can transmit data packets].  If an adapter is excluded, fall out of the loop.
					if (m_adapter.OperationalStatus != OperationalStatus.Up)
					{
						Console.WriteLine(string.Format("{0} has an operational status of {1}.  This adapter will not be used.", m_adapter.Description, m_adapter.OperationalStatus));
						continue;
					}

					// Filter to exclude network interfaces that do not support Internet Protocol version 4.  If an adapter is excluded, fall out of the loop.
					if (!m_adapter.Supports(NetworkInterfaceComponent.IPv4))
					{
						Console.WriteLine(string.Format("{0} supports IPv4 - {1}.  This adapter will not be used.", m_adapter.Description, !m_adapter.Supports(NetworkInterfaceComponent.IPv4)));
						continue;
					}

					// Filter to exclude loopback network interfaces and unknown network interfaces.  If an adapter is excluded, fall out of the loop.
					if (m_adapter.NetworkInterfaceType == NetworkInterfaceType.Loopback || m_adapter.NetworkInterfaceType == NetworkInterfaceType.Unknown)
					{
						Console.WriteLine(string.Format("{0} is a/an {1} type.  This adapter will not be used.", m_adapter.Description, m_adapter.NetworkInterfaceType));
						continue;
					}

					// Retrieve the properties of any adapters that meet the filter requirements.
					var m_props = m_adapter.GetIPProperties();

					// If there are no properties for this adapter, fall out of the loop.
					if (m_props == null)
					{
						Console.WriteLine(string.Format("There are no properties for adapter - {0}.  This adapter will not be used.", m_adapter.Description));
						continue;
					}

					// Filter to exclude network adapters that have no gateway address assigned to them.  If an adapter is excluded, fall out of the loop.
					if (m_props.GatewayAddresses.All(_gateway => _gateway.Address == new IPAddress(0)))
					{
						Console.WriteLine(string.Format("{0} has no gateway address(es) assigned - {1}.  This adapter will not be used.", m_adapter.Description, m_props.GatewayAddresses.All(_gateway => _gateway.Address == new IPAddress(0))));
						continue;
					}

					// Filter to exclude network adapters that have do not have a gateway address that matches the requested qateway, if any.  If an adapter is excluded, fall out of the loop.
					if (m_gateway != null && m_gateway != new IPAddress(0))
					{
						if (!m_props.GatewayAddresses.Any(_gateway => _gateway.Address.Equals(m_gateway)))
						{
							Console.WriteLine(string.Format("{0} has no gateway address(es) assigned that match -{1}.  This adapter will not be used.", m_adapter.Description, m_gateway));
							continue;
						}
					}

					// Retrieve the IPv4 properties of any adapters that meet the filter requirements
					var m_ipv4props = m_props.GetIPv4Properties();

					// Filter to exclude network adapters that have an automatice private addressing (APIPA) address assigned to them.  If an adapter is excluded, fall out of the loop.
					if (m_ipv4props.IsAutomaticPrivateAddressingActive)
					{
						Console.WriteLine(string.Format("{0} has an Automatic Private Addressing (APIPA) address assigned.  This adapter will not be used.", m_adapter.Description));
						continue;
					}

					// Retrieve the unicast addresses of any network adapters that meet the filter requirements.
					var m_unicastIPs = m_props.UnicastAddresses;

					// If there are no unicast ip addresses, fall out of the loop.
					if (m_unicastIPs == null)
					{
						Console.WriteLine(string.Format("{0} has no unicast address(es) assigned.  This adapter will not be used.", m_adapter.Description));
						continue;
					}

					foreach (var m_unicastIP in m_unicastIPs)
					{
						// Filter to exclude unicast addresses that do not have an IPv4 Subnet mask.  If a unicast address is excluded, fall out of the loop.
						if (m_unicastIP.IPv4Mask == null)
						{
							Console.WriteLine(string.Format("{0} has no IPv4 subnet mask.  This adapter will not be used.", m_adapter.Description));
							continue;
						}

						// Filter to exclude unicast addresses that are not valid and unrestricted.  If a unicast address is excluded, fall out of the loop.
						if (m_unicastIP.DuplicateAddressDetectionState != DuplicateAddressDetectionState.Preferred)
						{
							Console.WriteLine(string.Format("{0}'s duplicate detection state is {1}.  This adapter will not be used.", m_adapter.Description, m_unicastIP.DuplicateAddressDetectionState));
							continue;
						}

						//// Filter to exclude virtual netork addresses.  If a unicast address is excluded, fall out of the loop.
						//if (m_unicastIP.AddressPreferredLifetime == UInt32.MaxValue)
						//{
						//     Variables.FileLogger.RecordMessage(string.Format("Methods.GetIpAlternative: {0}'s unicast address {1} is a virtual address.  This adapter will not be used.", m_adapter.Description, m_unicastIP.Address), Log.MessageType.Informational);
						//     continue;
						//}

						// Filter to exclude addresses that are not IPv4 Addresses.  If a unicast address is excluded, fall out of the loop.
						if (m_unicastIP.Address.AddressFamily != AddressFamily.InterNetwork)
						{
							Console.WriteLine(string.Format("{0}'s unicast address {1} has an address family of {2}.  This adapter will not be used.", m_adapter.Description, m_unicastIP.Address, m_unicastIP.Address.AddressFamily));
							continue;
						}

						// Retrieve the IPAddress from the network interface.
						m_address = m_unicastIP.Address;

						Console.WriteLine(string.Format("Using adapter {0} with a unicast address of {1}.", m_adapter.Description, m_address));
					}

					if (BitConverter.ToUInt32(m_address.GetAddressBytes(), 0) != BitConverter.ToUInt32(new IPAddress(0).GetAddressBytes(), 0))
						break;
				}

				return BitConverter.ToUInt32(m_address.GetAddressBytes(), 0) == BitConverter.ToUInt32(new IPAddress(0).GetAddressBytes(), 0) ? null : m_address;
			}
			catch (NetworkInformationException ex)
			{
				// A windows system function call failed.
				Console.Write(string.Format("Network Information Exception reported in {0} - {1} [{2}]", ex.Source, ex, ex.Message));
				return null;
			}
			catch (PlatformNotSupportedException ex)
			{
				// This property is not valid on computers running operating systems earlier than Windows XP.
				Console.WriteLine(string.Format("Platform Not Supported Exception reported in {0} - {1} [{2}]", ex.Source, ex, ex.Message));
				return null;
			}
			catch (Exception ex)
			{
				// Generic exception.
				Console.WriteLine(string.Format("Exception reported in {0} - {1} [{2}]", ex.Source, ex, ex.Message));
				return null;
			}
		}
	}
}

Select allOpen in new window