Find the next TCP port in .NET

Question

I want to create a new net.tcp://localhost:x/Service endpoint for a WCF service call, with a dynamically assigned new open TCP port.

I know that TcpClient will assign a new client side port when I open a connection to a given server.

Is there a simple way to find the next open TCP port in .NET?

I need the actual number, so that I can build the string above. 0 does not work, since I need to pass that string to another process, so that I can call back on that new channel.

http://stackoverflow.com/questions/3563393/how-can-i-get-the-port-that-a-wcf-service-is-listening-on — keza, Apr 18 '12 at 05:29

score 152 · Accepted Answer · edited May 01 '12 at 13:16

152

Here is what I was looking for:

static int FreeTcpPort()
{
  TcpListener l = new TcpListener(IPAddress.Loopback, 0);
  l.Start();
  int port = ((IPEndPoint)l.LocalEndpoint).Port;
  l.Stop();
  return port;
}

edited May 01 '12 at 13:16

Bronumski

14,009
6
49
77

answered Sep 29 '08 at 22:15

TheSeeker

2,849
5
24
20

14

And what happens if another process opens that port before you re-open it...? – Mike Christiansen Sep 04 '09 at 01:08
9

Then you will get an error of course, but that was not an issue for my context. – TheSeeker Sep 11 '09 at 13:42
15

I successfully used this technique to get a free port. I too was concerned about race-conditions, with some other process sneaking in and grabbing the recently-detected-as-free port. So I wrote a test with a forced `Sleep(100)` between `var port = FreeTcpPort()` and starting an HttpListener on the free port. I then ran 8 identical processes hammering on this in a loop. I could never hit the race condition. My anecdotal evidence (Win 7) is that the OS apparently cycles through the range of ephemeral ports (a few thousand) before coming around again. So the above snippet should be just fine. – Doug Schmidt May 21 '14 at 16:07
3

If I understand how this works correctly, could you not just do this: `TcpListener myActualServer = new TcpListener(ipAddress, 0); myActualServer.Start(); return ((IPEndPoint)myActualServer.LocalEndpoint).Port;` or is it important that the OP gets the port before actually starting his listener? – JakeStrang Apr 25 '17 at 18:08
Tried to use this to make sure the unit tests on our build server run through, no matter what. But nope. With this piece of code some of them even fail on my local machine =/ – ecth Jul 17 '18 at 14:56
This solution is short and hacky --- I absolutely love it! – unknown6656 Mar 04 '20 at 09:49
One thing to note is that when I tried to use this piece of code, it prioritized ephemeral ports. This isn't necessarily a problem for most use cases, but it was for ours. – Connor McMahon Nov 03 '21 at 12:25

score 33 · Answer 2 · answered Sep 26 '08 at 06:35

33

Use a port number of 0. The TCP stack will allocate the next free one.

answered Sep 26 '08 at 06:35

Jerub

41,746
15
73
90

6

That does not work, since I need that actual #, not just 0. I need the number to build a string. – TheSeeker Sep 26 '08 at 07:07
This one has helped me. This actually does work, if you notify the other side what the port you're listening on is. – user35443 Dec 30 '14 at 08:38
1

ServiceHost host = new ServiceHost(typeof(MyService), new Uri("net.tcp://localhost:0/Service")); Is not going to work? – Joel McBeth Feb 04 '15 at 19:56
Yes, it works. You just have to set `endpoint.ListenUriMode` to `Unique`. – Yegor Aug 06 '15 at 05:01
This was a good solution for me. Using System.Net.Sockets.TcpClient. – Billy Bob Apr 18 '21 at 17:36

score 20 · Answer 3 · answered Mar 21 '18 at 13:55

It's a solution comparable to the accepted answer of TheSeeker. Though I think it's more readable:

using System;
using System.Net;
using System.Net.Sockets;

    private static readonly IPEndPoint DefaultLoopbackEndpoint = new IPEndPoint(IPAddress.Loopback, port: 0);

    public static int GetAvailablePort()
    {
        using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
        {
            socket.Bind(DefaultLoopbackEndpoint);
            return ((IPEndPoint)socket.LocalEndPoint).Port;
        }
    }

For UDP I used the following: `... SocketType.Dgram, ProtocolType.Udp...` — BatteryAcid, Jun 25 '20 at 02:33

score 13 · Answer 4 · answered Nov 18 '19 at 23:37

I found the following code from Selenium.WebDriver DLL

Namespace: OpenQA.Selenium.Internal

Class: PortUtility

public static int FindFreePort()
{
    int port = 0;
    Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    try
    {
        IPEndPoint localEP = new IPEndPoint(IPAddress.Any, 0);
        socket.Bind(localEP);
        localEP = (IPEndPoint)socket.LocalEndPoint;
        port = localEP.Port;
    }
    finally
    {
        socket.Close();
    }
    return port;
}

score 11 · Answer 5 · edited Apr 09 '19 at 19:29

If you just want to give a starting port, and let it return to you the next TCP port available, use code like this:

public static int GetAvailablePort(int startingPort)
{
    var portArray = new List<int>();

    var properties = IPGlobalProperties.GetIPGlobalProperties();

    // Ignore active connections
    var connections = properties.GetActiveTcpConnections();
    portArray.AddRange(from n in connections
                        where n.LocalEndPoint.Port >= startingPort
                        select n.LocalEndPoint.Port);

    // Ignore active tcp listners
    var endPoints = properties.GetActiveTcpListeners();
    portArray.AddRange(from n in endPoints
                        where n.Port >= startingPort
                        select n.Port);

    // Ignore active UDP listeners
    endPoints = properties.GetActiveUdpListeners();
    portArray.AddRange(from n in endPoints
                        where n.Port >= startingPort
                        select n.Port);

    portArray.Sort();

    for (var i = startingPort; i < UInt16.MaxValue; i++)
        if (!portArray.Contains(i))
            return i;

    return 0;
}

keep in mind that this will not work in Azure because of some restrictions. You would receive an Access Denied. The same by using netstat — Samuel Kupferschmid, Jul 13 '18 at 08:53
Thanks, this worked. Small addition: you can remove the UDP checks, because [TCP and UDP ports live in separate namespaces](https://stackoverflow.com/a/6437427/141397) — 3dGrabber, Jan 24 '20 at 12:36

score 9 · Answer 6 · answered Sep 26 '08 at 08:00

9

First open the port, then give the correct port number to the other process.

Otherwise it is still possible that some other process opens the port first and you still have a different one.

answered Sep 26 '08 at 08:00

jan.vdbergh

2,129
2
20
27

2

Do you have a code sample to get such a tcp port as easy as possible? – TheSeeker Sep 26 '08 at 21:35
This is the way to do it. Gotta be careful, could be a race condition if more than one process opens the same port. – Mike Christiansen Sep 04 '09 at 01:07

score 3 · Answer 7 · answered Oct 23 '19 at 16:00

Here's a more abbreviated way to implement this if you want to find the next available TCP port within a given range:

private int GetNextUnusedPort(int min, int max)
{
    if (max < min)
        throw new ArgumentException("Max cannot be less than min.");

    var ipProperties = IPGlobalProperties.GetIPGlobalProperties();

    var usedPorts =
        ipProperties.GetActiveTcpConnections()
            .Where(connection => connection.State != TcpState.Closed)
            .Select(connection => connection.LocalEndPoint)
            .Concat(ipProperties.GetActiveTcpListeners())
            .Concat(ipProperties.GetActiveUdpListeners())
            .Select(endpoint => endpoint.Port)
            .ToArray();

    var firstUnused =
        Enumerable.Range(min, max - min)
            .Where(port => !usedPorts.Contains(port))
            .Select(port => new int?(port))
            .FirstOrDefault();

    if (!firstUnused.HasValue)
        throw new Exception($"All local TCP ports between {min} and {max} are currently in use.");

    return firstUnused.Value;
}

score 1 · Answer 8 · edited Apr 09 '19 at 19:28

If you want to get a free port in a specific range in order to use it as local port / end point:

private int GetFreePortInRange(int PortStartIndex, int PortEndIndex)
{
    DevUtils.LogDebugMessage(string.Format("GetFreePortInRange, PortStartIndex: {0} PortEndIndex: {1}", PortStartIndex, PortEndIndex));
    try
    {
        IPGlobalProperties ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties();

        IPEndPoint[] tcpEndPoints = ipGlobalProperties.GetActiveTcpListeners();
        List<int> usedServerTCpPorts = tcpEndPoints.Select(p => p.Port).ToList<int>();

        IPEndPoint[] udpEndPoints = ipGlobalProperties.GetActiveUdpListeners();
        List<int> usedServerUdpPorts = udpEndPoints.Select(p => p.Port).ToList<int>();

        TcpConnectionInformation[] tcpConnInfoArray = ipGlobalProperties.GetActiveTcpConnections();
        List<int> usedPorts = tcpConnInfoArray.Where(p=> p.State != TcpState.Closed).Select(p => p.LocalEndPoint.Port).ToList<int>();

        usedPorts.AddRange(usedServerTCpPorts.ToArray());
        usedPorts.AddRange(usedServerUdpPorts.ToArray());

        int unusedPort = 0;

        for (int port = PortStartIndex; port < PortEndIndex; port++)
        {
            if (!usedPorts.Contains(port))
            {
                unusedPort = port;
                break;
            }
        }
        DevUtils.LogDebugMessage(string.Format("Local unused Port:{0}", unusedPort.ToString()));

        if (unusedPort == 0)
        {
            DevUtils.LogErrorMessage("Out of ports");
            throw new ApplicationException("GetFreePortInRange, Out of ports");
        }

        return unusedPort;
    }
    catch (Exception ex)
    {
        string errorMessage = ex.Message;
        DevUtils.LogErrorMessage(errorMessage);
        throw;
    }
}


private int GetLocalFreePort()
{
    int hemoStartLocalPort = int.Parse(DBConfig.GetField("Site.Config.hemoStartLocalPort"));
    int hemoEndLocalPort = int.Parse(DBConfig.GetField("Site.Config.hemoEndLocalPort"));
    int localPort = GetFreePortInRange(hemoStartLocalPort, hemoEndLocalPort);
    DevUtils.LogDebugMessage(string.Format("Local Free Port:{0}", localPort.ToString()));
    return localPort;
}


public void Connect(string host, int port)
{
    try
    {
        // Create socket
        Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        //socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);

        var localPort = GetLocalFreePort();
        // Create an endpoint for the specified IP on any port
        IPEndPoint bindEndPoint = new IPEndPoint(IPAddress.Any, localPort);

        // Bind the socket to the endpoint
        socket.Bind(bindEndPoint);

        // Connect to host
        socket.Connect(IPAddress.Parse(host), port);

        socket.Dispose();
    }
    catch (SocketException ex)
    {
        // Get the error message
        string errorMessage = ex.Message;
        DevUtils.LogErrorMessage(errorMessage);
    }
}


public void Connect2(string host, int port)
{
    try
    {
        // Create socket

        var localPort = GetLocalFreePort();

        // Create an endpoint for the specified IP on any port
        IPEndPoint bindEndPoint = new IPEndPoint(IPAddress.Any, localPort);

        var client = new TcpClient(bindEndPoint);
        //client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true); //will release port when done

        // Connect to the host
        client.Connect(IPAddress.Parse(host), port);

        client.Close();
    }
    catch (SocketException ex)
    {
        // Get the error message
        string errorMessage = ex.Message;
        DevUtils.LogErrorMessage(errorMessage);
    }
}

Find the next TCP port in .NET

8 Answers8

Linked