Em C #, como verificar se uma porta TCP está disponível?

Em C #, para usar um TcpClient ou geralmente para conectar a um soquete, como posso primeiro verificar se uma determinada porta está livre na minha máquina?

mais informações: Este é o código que uso:

TcpClient c;
//I want to check here if port is free.
c = new TcpClient(ip, port);

Como você está usando um TcpClient, significa que está verificando as portas TCP abertas. Existem muitos objetos bons disponíveis no namespace System.Net.NetworkInformation .

Use o IPGlobalPropertiesobjeto para chegar a uma matriz de TcpConnectionInformationobjetos, que você pode interrogar sobre o IP e a porta do endpoint.

 int port = 456; //<--- This is your value
 bool isAvailable = true;

 // Evaluate current system tcp connections. This is the same information provided
 // by the netstat command line application, just in .Net strongly-typed object
 // form.  We will look through the list, and if our port we would like to use
 // in our TcpClient is occupied, we will set isAvailable to false.
 IPGlobalProperties ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties();
 TcpConnectionInformation[] tcpConnInfoArray = ipGlobalProperties.GetActiveTcpConnections();

 foreach (TcpConnectionInformation tcpi in tcpConnInfoArray)
 {
   if (tcpi.LocalEndPoint.Port==port)
   {
     isAvailable = false;
     break;
   }
 }

 // At this point, if isAvailable is true, we can proceed accordingly.

Você está do lado errado do Intertube. É o servidor que pode ter apenas uma porta específica aberta. Algum código:

  IPAddress ipAddress = Dns.GetHostEntry("localhost").AddressList[0];
  try {
    TcpListener tcpListener = new TcpListener(ipAddress, 666);
    tcpListener.Start();
  }
  catch (SocketException ex) {
    MessageBox.Show(ex.Message, "kaboom");
  }

Falha com:

Normalmente, apenas um uso de cada endereço de soquete (protocolo / endereço de rede / porta) é permitido.

Quando você configura uma conexão TCP, a 4-tupla (ip-fonte, porta-fonte, ip-dest, porta-dest) deve ser única - isso é para garantir que os pacotes sejam entregues no lugar certo.

Há uma outra restrição no lado do servidor , de que apenas um programa de servidor pode se vincular a um número de porta de entrada (assumindo um endereço IP; os servidores multi-NIC têm outros poderes, mas não precisamos discuti-los aqui).

Então, na extremidade do servidor, você:

• crie um soquete.
• ligue esse soquete a uma porta.
• escute nessa porta.
• aceitar conexões nessa porta. e pode haver várias conexões chegando (uma por cliente).

No lado do cliente, geralmente é um pouco mais simples:

• crie um soquete.
• abra a conexão. Quando um cliente abre a conexão, ele especifica o endereço IP e a porta do servidor . Ele pode especificar sua porta de origem, mas geralmente usa zero, o que resulta na atribuição automática de uma porta livre pelo sistema.

Não há exigência de que o IP / porta de destino seja exclusivo, pois isso resultaria em apenas uma pessoa por vez ser capaz de usar o Google, e isso destruiria muito bem seu modelo de negócios.

Isso significa que você pode até fazer coisas maravilhosas como FTP de várias sessões, já que configura várias sessões em que a única diferença é sua porta de origem, permitindo que você baixe pedaços em paralelo. Torrents são um pouco diferentes porque o destino de cada sessão geralmente é diferente.

E, depois de todo aquele waffling (desculpe), a resposta à sua pergunta específica é que você não precisa especificar uma porta livre. Se você estiver se conectando a um servidor com uma chamada que não especifica sua porta de origem, quase certamente estará usando zero nos bastidores e o sistema fornecerá uma porta não utilizada.

TcpClient c;

//I want to check here if port is free.
c = new TcpClient(ip, port);

... como posso verificar primeiro se uma determinada porta está livre em minha máquina?

Quero dizer que não está em uso por nenhum outro aplicativo. Se um aplicativo estiver usando uma porta, outros não poderão usá-lo até que se torne gratuito. - Todos

Você entendeu mal o que está acontecendo aqui.

Os parâmetros TcpClient (...) são do ip do servidor e da porta do servidor ao qual você deseja se conectar.

O TcpClient seleciona uma porta local temporária do pool disponível para se comunicar com o servidor. Não há necessidade de verificar a disponibilidade da porta local, pois ela é tratada automaticamente pela camada winsock.

Caso você não consiga se conectar ao servidor usando o fragmento de código acima, o problema pode ser um ou mais de vários. (ou seja, o ip e / ou porta do servidor está errado, o servidor remoto não está disponível, etc.)

Obrigado por esta dica. Eu precisava da mesma funcionalidade, mas no lado do servidor para verificar se uma porta estava em uso, então modifiquei para este código.

 private bool CheckAvailableServerPort(int port) {
    LOG.InfoFormat("Checking Port {0}", port);
    bool isAvailable = true;

    // Evaluate current system tcp connections. This is the same information provided
    // by the netstat command line application, just in .Net strongly-typed object
    // form.  We will look through the list, and if our port we would like to use
    // in our TcpClient is occupied, we will set isAvailable to false.
    IPGlobalProperties ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties();
    IPEndPoint[] tcpConnInfoArray = ipGlobalProperties.GetActiveTcpListeners();

    foreach (IPEndPoint endpoint in tcpConnInfoArray) {
        if (endpoint.Port == port) {
            isAvailable = false;
            break;
        }
    }

    LOG.InfoFormat("Port {0} available = {1}", port, isAvailable);

    return isAvailable;
}

obrigado pela resposta jro. Eu tive que ajustá-lo para meu uso. Eu precisava verificar se uma porta estava sendo ouvida e não necessariamente ativa. Por isso eu substituí

TcpConnectionInformation[] tcpConnInfoArray = ipGlobalProperties.GetActiveTcpConnections();

com

IPEndPoint[] objEndPoints = ipGlobalProperties.GetActiveTcpListeners();.  

Eu iterou a matriz de endpoints verificando se meu valor de porta não foi encontrado.

string hostname = "localhost";
int portno = 9081;
IPAddress ipa = (IPAddress) Dns.GetHostAddresses(hostname)[0];


try
{
    System.Net.Sockets.Socket sock = new System.Net.Sockets.Socket(System.Net.Sockets.AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp);
    sock.Connect(ipa, portno);
    if (sock.Connected == true)  // Port is in use and connection is successful
            MessageBox.Show("Port is Closed");
    sock.Close();

}
catch (System.Net.Sockets.SocketException ex)
{
    if (ex.ErrorCode == 10061)  // Port is unused and could not establish connection 
        MessageBox.Show("Port is Open!");
    else
        MessageBox.Show(ex.Message);
}

netstat! É um utilitário de linha de comando de rede que vem com o Windows. Mostra todas as conexões estabelecidas atualmente e todas as portas que estão sendo ouvidas. Você pode usar este programa para verificar, mas se quiser fazer isso a partir do código, procure no namespace System.Net.NetworkInformation? É um novo namespace a partir de 2.0. Tem algumas guloseimas lá. Mas, eventualmente, se você quiser obter o mesmo tipo de informação que está disponível através do comando netstat, você precisará obter o resultado para P / Invoke ...

Atualização: System.Net.NetworkInformation

Esse namespace contém um monte de classes que você pode usar para descobrir coisas sobre a rede.

Não consegui encontrar aquele pedaço de código antigo, mas acho que você mesmo pode escrever algo semelhante. Um bom começo é verificar a API IP Helper . Google MSDN para o função GetTcpTable WINAPI e use P / Invoke para enumerar até que você tenha as informações de que precisa.

Se não me engano, você pode usar System.Network.whatever para verificar.

No entanto, isso sempre incorrerá em uma condição de corrida.

A maneira canônica de verificação é tentar escutar nessa porta. Se você receber um erro, a porta não foi aberta.

Acho que isso é parte do motivo pelo qual bind () e listen () são duas chamadas de sistema separadas.

Você diz

Quero dizer que não está em uso por nenhum outro aplicativo. Se um aplicativo estiver usando uma porta, outros não poderão usá-lo até que se torne gratuito.

Mas você sempre pode se conectar a uma porta enquanto outras pessoas a estão usando, se algo estiver ouvindo lá. Caso contrário, a porta 80 http seria uma bagunça.

Se seu

   c = new TcpClient(ip, port);

falhar, então nada está ouvindo lá. Caso contrário, ele se conectará, mesmo que alguma outra máquina / aplicativo tenha um soquete aberto para aquele ip e porta.

ipGlobalProperties.GetActiveTcpConnections() não retorna conexões no estado de escuta.

A porta pode ser usada para escuta, mas sem ninguém conectado a ela, o método descrito acima não funcionará.

Das portas disponíveis, eu excluiria:

• conexões TCP ativas
• ouvintes TCP ativos
• ouvintes UDP ativos

Com a seguinte importação:

using System.Net.NetworkInformation;

Você pode usar a seguinte função para verificar se uma porta está disponível ou não:

private bool isPortAvalaible(int myPort)
{
    var avalaiblePorts = new List<int>();
    var properties = IPGlobalProperties.GetIPGlobalProperties();

    // Active connections
    var connections = properties.GetActiveTcpConnections();
    avalaiblePorts.AddRange(connections);

    // Active tcp listners
    var endPointsTcp = properties.GetActiveTcpListeners();
    avalaiblePorts.AddRange(endPointsTcp);

    // Active udp listeners
    var endPointsUdp = properties.GetActiveUdpListeners();
    avalaiblePorts.AddRange(endPointsUdp);

    foreach (int p in avalaiblePorts){
        if (p == myPort) return false;
    }
    return true;
}

Eu ofereço uma função semelhante para aqueles que usam VB.NET :

Imports System.Net.NetworkInformation
Private Function isPortAvalaible(ByVal myPort As Integer) As Boolean
  Dim props As IPGlobalProperties = IPGlobalProperties.GetIPGlobalProperties()

  ' ignore active connections
  Dim tcpConnInfoArray() As TcpConnectionInformation = props.GetActiveTcpConnections()
  For Each tcpi As Net.NetworkInformation.TcpConnectionInformation In tcpConnInfoArray
    If tcpi.LocalEndPoint.Port = myPort Then
      Return False
    End If
  Next tcpi

  ' ignore active TCP listeners
  Dim activeTcpListeners() As Net.IPEndPoint = props.GetActiveTcpListeners
  For Each tcpListener As Net.IPEndPoint In activeTcpListeners
    If tcpListener.Port = myPort Then
      Return False
    End If
  Next tcpListener

  ' ignore active UPD listeners
  Dim activeUdpListeners() As Net.IPEndPoint = props.GetActiveUdpListeners
  For Each udpListener As Net.IPEndPoint In activeUdpListeners
    If udpListener.Port = myPort Then
      Return False
    End If
  Next udpListener

  Return True
End Function

Para responder à pergunta exata de encontrar uma porta livre (que é o que eu precisava em meus testes de unidade) no dotnet core 3.1 eu vim

public static int GetAvailablePort(IPAddress ip) {
        TcpListener l = new TcpListener(ip, 0);
        l.Start();
        int port = ((IPEndPoint)l.LocalEndpoint).Port;
        l.Stop();
        Log.Info($"Available port found: {port}");
        return port;
    }

nota: com base no comentário de @ user207421 sobre a porta zero, pesquisei e encontrei isso e modifiquei ligeiramente.

Fique atento ao intervalo de tempo entre você fazer a verificação e o momento em que tenta fazer a conexão algum processo pode tomar a porta - o clássico TOCTOU . Por que você simplesmente não tenta se conectar? Se falhar, você sabe que a porta não está disponível.

Você não precisa saber quais portas estão abertas em sua máquina local para se conectar a algum serviço TCP remoto (a menos que queira usar uma porta local específica, mas geralmente esse não é o caso).

Cada conexão TCP / IP é identificada por 4 valores: IP remoto, número da porta remota, IP local, número da porta local, mas você só precisa saber o IP remoto e o número da porta remota para estabelecer uma conexão.

Quando você cria uma conexão tcp usando

TcpClient c;
c = novo TcpClient (remote_ip, remote_port);

Seu sistema atribuirá automaticamente um dos muitos números de porta local gratuitos à sua conexão. Você não precisa fazer nada. Você também pode querer verificar se uma porta remota está aberta. mas não há maneira melhor de fazer isso do que apenas tentando se conectar a ele.

    public static bool TestOpenPort(int Port)
    {
        var tcpListener = default(TcpListener);

        try
        {
            var ipAddress = Dns.GetHostEntry("localhost").AddressList[0];

            tcpListener = new TcpListener(ipAddress, Port);
            tcpListener.Start();

            return true;
        }
        catch (SocketException)
        {
        }
        finally
        {
            if (tcpListener != null)
                tcpListener.Stop();
        }

        return false;
    }

test_connection("ip", port);


public void test_connection(String hostname, int portno) {
  IPAddress ipa = (IPAddress)Dns.GetHostAddresses(hostname)[0];
  try {
    System.Net.Sockets.Socket sock = new System.Net.Sockets.Socket(System.Net.Sockets.AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp);
   sock.Connect(ipa, portno);
   if (sock.Connected == true) {
     MessageBox.Show("Port is in use");
   }

   sock.Close();
 }
 catch (System.Net.Sockets.SocketException ex) {
   if (ex.ErrorCode == 10060) {
     MessageBox.Show("No connection.");
   }
 }
}

Verifique o código de erro 10048

try
{
    TcpListener tcpListener = new TcpListener(ipAddress, portNumber);
    tcpListener.Start();
}
catch(SocketException ex)
{
    if(ex.ErrorCode == 10048)
    {
        MessageBox.Show("Port " + portNumber + " is currently in use.");
    }
    return;
}

tente isso, no meu caso o número da porta para o objeto criado não estava disponível, então eu vim com este

IPEndPoint endPoint;
int port = 1;
while (true)
{
    try
    {
        endPoint = new IPEndPoint(IPAddress.Any, port);
        break;
    }
    catch (SocketException)
    {
         port++;
    }
}