Método para determinar si la cadena de ruta es una máquina local o remota

Question

¿Cuál es la mejor manera, utilizando C# u otro lenguaje .NET, para determinar si una cadena de ruta de archivo está en la máquina local o en un servidor remoto?

Es posible determinar si una cadena de ruta es UNC utilizando la siguiente:

new Uri(path).IsUnc 

que funciona muy bien para las rutas que comienzan con C: \ u otra letra de unidad, pero ¿qué pasa con senderos como:

\\machinename\sharename\directory 
\\10.12.34.56\sharename\directory 

... donde ambos hacen referencia a la máquina local; estas son rutas UNC pero siguen siendo locales.

Answer 1

No sabe si hay una manera más eficiente de hacer esto, pero parece que funciona para mí:

IPAddress[] host; 
    IPAddress[] local; 
    bool isLocal = false; 

    host = Dns.GetHostAddresses(uri.Host); 
    local = Dns.GetHostAddresses(Dns.GetHostName()); 

    foreach (IPAddress hostAddress in host) 
    { 
     if (IPAddress.IsLoopback(hostAddress)) 
     { 
      isLocal = true; 
      break; 
     } 
     else 
     { 
      foreach (IPAddress localAddress in local) 
      { 
       if (hostAddress.Equals(localAddress)) 
       { 
        isLocal = true; 
        break; 
       } 
      } 

      if (isLocal) 
      { 
       break; 
      } 
     } 
    } 

Answer 2

No conozco un solo método para verificarlo. Sin embargo, puede comparar la propiedad Host de Uri con el nombre de host local o la dirección IP.

Usted puede obtener el nombre de la máquina local usando:

string hostName = System.Net.Dns.GetHostName() 

A continuación, puede obtener una matriz de direcciones IP al pasar esa cadena a:

System.Net.IPAddress[] addresses = System.Net.Dns.GetHostAddresses(hostName); 

Encienda HostNameType propiedad del Uri, probablemente UriHostNameType.Dns o UriHostNameType.IPv4, para que coincida con el nombre o la dirección IP.

Answer 3

Ésta es la forma en que lo hice.

public static bool IsLocal(DirectoryInfo dir) 
    { 
     foreach (DriveInfo d in DriveInfo.GetDrives()) 
     { 
      if (string.Compare(dir.Root.FullName, d.Name, StringComparison.OrdinalIgnoreCase) == 0) //[drweb86] Fix for different case. 
      { 
       return (d.DriveType != DriveType.Network); 
      } 
     } 
     throw new DriveNotFoundException(); 
    } 

Answer 4

.NET 3.5 versión de la respuesta de Eric con una comprobación adicional si existe el anfitrión:

private bool IsLocalHost(string input) 
    { 
     IPAddress[] host; 
     //get host addresses 
     try { host = Dns.GetHostAddresses(input); } 
     catch (Exception) { return false; } 
     //get local adresses 
     IPAddress[] local = Dns.GetHostAddresses(Dns.GetHostName()); 
     //check if local 
     return host.Any(hostAddress => IPAddress.IsLoopback(hostAddress) || local.Contains(hostAddress)); 
    } 

Answer 5

Tal

var isLocal = Dns.GetHostName() == _host || Dns.GetHostEntry(Dns.GetHostName()).AddressList.Any(i => i.ToString().Equals(_host)); 

Answer 6

Lo que sigue debe trabajar para las unidades asignadas y para rutas UNC.

private static bool IsLocalPath(String path) 
{ 
    if (!PathIsUNC(path)) 
    { 
     return !PathIsNetworkPath(path); 
    } 

    Uri uri = new Uri(path); 
    return IsLocalHost(uri.Host); // Refer to David's answer 
} 

[DllImport("Shlwapi.dll")] 
[return: MarshalAs(UnmanagedType.Bool)] 
static extern bool PathIsNetworkPath(String pszPath); 

[DllImport("Shlwapi.dll")] 
[return: MarshalAs(UnmanagedType.Bool)] 
static extern bool PathIsUNC(String pszPath); 

Answer 7

Así es como me dirigí a una necesidad similar.

 internal static bool IsFileRemote(string path) 
    { 
      if (String.IsNullOrEmpty(path)) 
      { 
       return false; 
      } 
      if (new Uri(path).IsUnc) 
      { 
       return true; 
      } 
      if (new DriveInfo(path).DriveType == DriveType.Network) 
      { 
       return true; 
      } 
      return false; 
    }