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

Question

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

Il est possible de déterminer si une chaîne de chemin d'accès est UNC en utilisant ce qui suit:

 new Uri(path).IsUnc
 

Cela fonctionne très bien pour les chemins qui commencent par C: \ ou une autre lettre de lecteur, mais qu'en est-il des chemins comme:

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

... où les deux font référence à la machine locale - ce sont des chemins UNC mais toujours locaux.

Answer 1

C'est comme ça que 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 2

Je ne sais pas s'il existe un moyen plus efficace de le faire, mais cela 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 3

Version .NET 3.5 de la réponse d'Eric avec une vérification 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 4

Les éléments suivants devraient fonctionner pour les lecteurs mappés 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 5

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