¿Cómo encontrar el FQDN de la máquina local en C # / .NET?

¿Cómo puede obtener el FQDN de una máquina local en C #?

NOTA: Esta solución solo funciona cuando se dirige a los marcos .NET 2.0 (y más nuevos).

using System;
using System.Net;
using System.Net.NetworkInformation;
//...

public static string GetFQDN()
{
    string domainName = IPGlobalProperties.GetIPGlobalProperties().DomainName;
    string hostName = Dns.GetHostName();

    domainName = "." + domainName;
    if(!hostName.EndsWith(domainName))  // if hostname does not already include domain name
    {
        hostName += domainName;   // add the domain name part
    }

    return hostName;                    // return the fully qualified name
}

ACTUALIZAR

Dado que mucha gente ha comentado que la respuesta de Sam es más concisa, he decidido agregar algunos comentarios a la respuesta.

Lo más importante a tener en cuenta es que el código que di no es equivalente al siguiente código:

Dns.GetHostEntry("LocalHost").HostName

Mientras que en el caso general cuando la máquina está en red y es parte de un dominio, ambos métodos generalmente producirán el mismo resultado, en otros escenarios los resultados serán diferentes.

Un escenario donde la salida será diferente es cuando la máquina no es parte de un dominio. En este caso, Dns.GetHostEntry("LocalHost").HostNamevolverá localhostmientras que el GetFQDN()método anterior devolverá el nombre NETBIOS del host.

Esta distinción es importante cuando el propósito de encontrar el FQDN de la máquina es registrar información o generar un informe. La mayoría de las veces he utilizado este método en registros o informes que se utilizan posteriormente para asignar información a una máquina específica. Si las máquinas no están en red, el localhostidentificador es inútil, mientras que el nombre proporciona la información necesaria.

Así que, en última instancia, depende de cada usuario qué método se adapta mejor a su aplicación, según el resultado que necesite. Pero decir que esta respuesta es incorrecta por no ser lo suficientemente concisa es, en el mejor de los casos, superficial.

Vea un ejemplo donde la salida será diferente: http://ideone.com/q4S4I0

Una ligera simplificación del código de Miky D

    public static string GetLocalhostFqdn()
    {
        var ipProperties = IPGlobalProperties.GetIPGlobalProperties();
        return string.Format("{0}.{1}", ipProperties.HostName, ipProperties.DomainName);
    }

Esto está cubierto por este artículo . Esta técnica es más breve que la respuesta aceptada y probablemente más confiable que la siguiente respuesta más votada. Tenga en cuenta que, según tengo entendido, esto no usa nombres NetBIOS, por lo que debería ser adecuado para uso en Internet.

.NET 2.0+

Dns.GetHostEntry("LocalHost").HostName

.NET 1.0 - 1.1

Dns.GetHostByName("LocalHost").HostName

Aquí está en PowerShell, por el gusto de hacerlo:

$ipProperties = [System.Net.NetworkInformation.IPGlobalProperties]::GetIPGlobalProperties()
"{0}.{1}" -f $ipProperties.HostName, $ipProperties.DomainName

Y para Framework 1.1 es tan simple como esto:

System.Net.Dns.GetHostByName("localhost").HostName

Y luego elimine el nombre NETBIOS de la máquina para recuperar solo el nombre de dominio

Puedes probar lo siguiente:

return System.Net.Dns.GetHostEntry(Environment.MachineName).HostName;

Esto debería darle el FQDN de la máquina local actual (o puede especificar cualquier host).

Una ligera mejora en la respuesta de Matt Z para que no se devuelva un punto final si la computadora no es miembro de un dominio:

public static string GetLocalhostFqdn()
{
    var ipProperties = IPGlobalProperties.GetIPGlobalProperties();
    return string.IsNullOrWhiteSpace(ipProperties.DomainName) ? ipProperties.HostName : string.Format("{0}.{1}", ipProperties.HostName, ipProperties.DomainName);
}

Usé esto como una de mis opciones para combinar el nombre de host y el nombre de dominio para crear un informe, agregué el texto genérico para completar cuando no se capturó el nombre de dominio, este era uno de los requisitos del cliente.

Probé esto usando C # 5.0, .Net 4.5.1

private static string GetHostnameAndDomainName()
{
       // if No domain name return a generic string           
       string currentDomainName = IPGlobalProperties.GetIPGlobalProperties().DomainName ?? "nodomainname";
       string hostName = Dns.GetHostName();

    // check if current hostname does not contain domain name
    if (!hostName.Contains(currentDomainName))
    {
        hostName = hostName + "." + currentDomainName;
    }
    return hostName.ToLower();  // Return combined hostname and domain in lowercase
} 

Construido con ideas de la solución Miky Dinescu.

Hemos implementado el resultado sugerido para usar de esta manera:

return System.Net.Dns.GetHostEntry(Environment.MachineName).HostName;

Sin embargo, resultó que esto no funciona bien cuando el nombre de la computadora tiene más de 15 caracteres y usa el nombre NetBios. Environment.MachineName devuelve solo un nombre parcial y la resolución del nombre de host devuelve el mismo nombre de computadora.

Después de investigar un poco, encontramos una solución para solucionar este problema:

System.Net.Dns.GetHostEntry(System.Net.Dns.GetHostName()).HostName

Esto resolvió todos los problemas, incluido el nombre de la computadora.

He usado este enfoque:

private static string GetLocalhostFQDN()
{
    var ipProperties = IPGlobalProperties.GetIPGlobalProperties();
    return $"{ipProperties.HostName}.{ipProperties.DomainName}";
}

Ninguna de las respuestas proporcionadas que probé en realidad proporcionó el sufijo DNS que estaba buscando. Esto es lo que se me ocurrió.

public static string GetFqdn()
{
    var networkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
    var ipprops = networkInterfaces.First().GetIPProperties();
    var suffix = ipprops.DnsSuffix;
    return $"{IPGlobalProperties.GetIPGlobalProperties().HostName}.{suffix}";
}

Si desea ordenarlo y manejar excepciones, intente esto:

public static string GetLocalhostFQDN()
        {
            string domainName = string.Empty;
            try
            {
                domainName = NetworkInformation.IPGlobalProperties.GetIPGlobalProperties().DomainName;
            }
            catch
            {
            }
            string fqdn = "localhost";
            try
            {
                fqdn = System.Net.Dns.GetHostName();
                if (!string.IsNullOrEmpty(domainName))
                {
                    if (!fqdn.ToLowerInvariant().EndsWith("." + domainName.ToLowerInvariant()))
                    {
                        fqdn += "." + domainName;
                    }
                }
            }
            catch
            {
            }
            return fqdn;
        }