Méthode permettant de déterminer si la chaîne de chemin est une machine locale ou distante

Question

Quelle est la meilleure façon d'utiliser C# ou un autre langage .NET pour déterminer si une chaîne de chemin de fichier se trouve sur la machine locale ou sur un serveur distant?

Il est possible de déterminer si une chaîne de chemin est UNC en utilisant les éléments suivants:

new Uri(path).IsUnc 

Cela fonctionne très bien pour les chemins qui commencent par C: \ ou autre lettre de lecteur, mais ce que sur les chemins comme:

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

... où les deux se réfèrent à la machine locale - ce sont des chemins UNC mais sont encore locaux.

Answer 1

Je ne sais pas s'il y a un moyen plus efficace de le faire, mais il semble fonctionner pour moi:

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

Je ne connais pas de méthode unique pour vérifier cela. Cependant, vous pouvez comparer la propriété Host de Uri au nom d'hôte local ou à l'adresse IP.

Vous pouvez obtenir le nom de la machine locale en utilisant:

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

Vous pouvez alors obtenir un tableau d'adresses IP en passant cette chaîne:

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

Enclencher la propriété d'Uri HostNameType, probablement UriHostNameType.Dns ou UriHostNameType.IPv4, pour correspondre au nom ou à l'adresse IP.

Answer 3

Voilà comment je l'ai fait.

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

la version .NET 3.5 de la réponse d'Eric avec un contrôle supplémentaire si l'hôte existe:

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

Peut-être

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

Answer 6

Les éléments suivants doivent travailler pour des lecteurs et pour les chemins 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

Voici comment j'ai répondu à un besoin similaire.

 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; 
    }