Wie ermittle ich den tatsächlichen Pfad eines zugeordneten Laufwerks?

Dehnte ich auf ibram Antwort und erstellt diese Klasse (die aktualisiert wurde per Kommentar feedback). Ich habe wahrscheinlich mehr dokumentiert, aber es sollte selbsterklärend sein.

///<summary>
///A static class to help with resolving a mapped drive path to a UNC network path.
///If a local drive path or a UNC network path are passed in, they will just be returned.
///</summary>
///<example>
///using System;
///using System.IO;
///using System.Management;    //Reference System.Management.dll
///
/////Example/Test paths, these will need to be adjusted to match your environment. 
///string[] paths = new string[] {
///    @"Z:\ShareName\Sub-Folder",
///    @"\\ACME-FILE\ShareName\Sub-Folder",
///    @"\\ACME.COM\ShareName\Sub-Folder", //DFS
///    @"C:\Temp",
///    @"\\localhost\c$\temp",
///    @"\\workstation\Temp",
///    @"Z:", //Mapped drive pointing to \\workstation\Temp
///    @"C:\",
///    @"Temp",
///    @".\Temp",
///    @"..\Temp",
///    "",
///    "    ",
///    null
///};
///
///foreach (var curPath in paths) {
///    try {
///        Console.WriteLine(string.Format("{0} = {1}",
///            curPath,
///            MappedDriveResolver.ResolveToUNC(curPath))
///        );
///    }
///    catch (Exception ex) {
///        Console.WriteLine(string.Format("{0} = {1}",
///            curPath,
///            ex.Message)
///        );
///    }
///}
///</example>
public static class MappedDriveResolver
{
    ///<summary>
    ///Resolves the given path to a full UNC path if the path is a mapped drive.
    ///Otherwise, just returns the given path.
    ///</summary>
    ///<param name="path">The path to resolve.</param>
    ///<returns></returns>
    public static string ResolveToUNC(string path) {
        if (String.IsNullOrWhiteSpace(path)) {
            throw new ArgumentNullException("The path argument was null or whitespace.");
        }

        if (!Path.IsPathRooted(path)) {
            throw new ArgumentException(
                string.Format("The path '{0}' was not a rooted path and ResolveToUNC does not support relative paths.",
                    path)
            );
        }

        //Is the path already in the UNC format?
        if (path.StartsWith(@"\\")) {
            return path;
        }

        string rootPath = ResolveToRootUNC(path);

        if (path.StartsWith(rootPath)) {
            return path; //Local drive, no resolving occurred
        }
        else {
            return path.Replace(GetDriveLetter(path), rootPath);
        }
    }

    ///<summary>
    ///Resolves the given path to a root UNC path if the path is a mapped drive.
    ///Otherwise, just returns the given path.
    ///</summary>
    ///<param name="path">The path to resolve.</param>
    ///<returns></returns>
    public static string ResolveToRootUNC(string path) {
        if (String.IsNullOrWhiteSpace(path)) {
            throw new ArgumentNullException("The path argument was null or whitespace.");
        }

        if (!Path.IsPathRooted(path)) {
            throw new ArgumentException(
                string.Format("The path '{0}' was not a rooted path and ResolveToRootUNC does not support relative paths.",
                path)
            );
        }

        if (path.StartsWith(@"\\")) {
            return Directory.GetDirectoryRoot(path);
        }

        //Get just the drive letter for WMI call
        string driveletter = GetDriveLetter(path);

        //Query WMI if the drive letter is a network drive, and if so the UNC path for it
        using (ManagementObject mo = new ManagementObject()) {
            mo.Path = new ManagementPath(string.Format("Win32_LogicalDisk='{0}'", driveletter));

            DriveType driveType = (DriveType)((uint)mo["DriveType"]);
            string networkRoot = Convert.ToString(mo["ProviderName"]);

            if (driveType == DriveType.Network) {
                return networkRoot;
            }
            else {
                return driveletter + Path.DirectorySeparatorChar;
            }
        }           
    }

    ///<summary>
    ///Checks if the given path is a network drive.
    ///</summary>
    ///<param name="path">The path to check.</param>
    ///<returns></returns>
    public static bool isNetworkDrive(string path) {
        if (String.IsNullOrWhiteSpace(path)) {
            throw new ArgumentNullException("The path argument was null or whitespace.");
        }

        if (!Path.IsPathRooted(path)) {
            throw new ArgumentException(
                string.Format("The path '{0}' was not a rooted path and ResolveToRootUNC does not support relative paths.",
                path)
            );
        }

        if (path.StartsWith(@"\\")) {
            return true;
        }

        //Get just the drive letter for WMI call
        string driveletter = GetDriveLetter(path);

        //Query WMI if the drive letter is a network drive
        using (ManagementObject mo = new ManagementObject()) {
            mo.Path = new ManagementPath(string.Format("Win32_LogicalDisk='{0}'", driveletter));
            DriveType driveType = (DriveType)((uint)mo["DriveType"]);
            return driveType == DriveType.Network;
        }
    }

    ///<summary>
    ///Given a path will extract just the drive letter with volume separator.
    ///</summary>
    ///<param name="path"></param>
    ///<returns>C:</returns>
    public static string GetDriveLetter(string path) {
        if (String.IsNullOrWhiteSpace(path)) {
            throw new ArgumentNullException("The path argument was null or whitespace.");
        }

        if (!Path.IsPathRooted(path)) {
            throw new ArgumentException(
                string.Format("The path '{0}' was not a rooted path and GetDriveLetter does not support relative paths.",
                path)
            );
        }

        if (path.StartsWith(@"\\")) {
            throw new ArgumentException("A UNC path was passed to GetDriveLetter");
        }

        return Directory.GetDirectoryRoot(path).Replace(Path.DirectorySeparatorChar.ToString(), "");
    }
}

InformationsquelleAutor der Antwort Vermis

Habe ich geschrieben eine Methode dafür. Es gibt einen UNC-Pfad, wenn Sie ein zugeordnetes Laufwerk, sonst gibt es den Pfad unverändert.

public static string UNCPath(string path)
{
    using (RegistryKey key = Registry.CurrentUser.OpenSubKey("Network\\" + path[0]))
    {
        if (key != null)
        {
            path = key.GetValue("RemotePath").ToString() + path.Remove(0, 2).ToString();
        }
    }
    return path;
}

BEARBEITEN

Können Sie jetzt mit der Methode auch schon mit UNC-Pfade. Die obige version der Methode eine Ausnahme auslöst, wenn da ein UNC-Pfad.

public static string UNCPath(string path)
{
    if (!path.StartsWith(@"\\"))
    {
        using (RegistryKey key = Registry.CurrentUser.OpenSubKey("Network\\" + path[0]))
        {
            if (key != null)
            {
                return key.GetValue("RemotePath").ToString() + path.Remove(0, 2).ToString();
            }
        }
    }
    return path;
}

InformationsquelleAutor der Antwort cramopy

Konnte ich nicht replizieren ibram ist oder Vermis' Antwort wegen dem problem, das ich erwähnte in einem Kommentar unter Vermis " Antwort, über eine typeninitialisierer Ausnahme.

Stattdessen entdeckte ich, ich könnte die Abfrage für alle Laufwerke, die derzeit auf dem computer und dann eine Schleife, etwa so:

using System.IO; //For DirectoryNotFound exception.
using System.Management;


///<summary>
///Given a local mapped drive letter, determine if it is a network drive. If so, return the server share.
///</summary>
///<param name="mappedDrive"></param>
///<returns>The server path that the drive maps to ~ "////XXXXXX//ZZZZ"</returns>
private string CheckUNCPath(string mappedDrive)
{
    //Query to return all the local computer's drives.
    //See http://msdn.microsoft.com/en-us/library/ms186146.aspx, or search "WMI Queries"
    SelectQuery selectWMIQuery = new SelectQuery("Win32_LogicalDisk");
    ManagementObjectSearcher driveSearcher = new ManagementObjectSearcher(selectWMIQuery);

    //Soem variables to be used inside and out of the foreach.
    ManagementPath path = null;
    ManagementObject networkDrive = null;
    bool found = false;
    string serverName = null;

    //Check each disk, determine if it is a network drive, and then return the real server path.
    foreach (ManagementObject disk in driveSearcher.Get())
    {
        path = disk.Path;

        if (path.ToString().Contains(mappedDrive))
        {
            networkDrive = new ManagementObject(path);

            if (Convert.ToUInt32(networkDrive["DriveType"]) == 4)
            {
                serverName = Convert.ToString(networkDrive["ProviderName"]);
                found = true;
                break;
            }
            else
            {
                throw new DirectoryNotFoundException("The drive " + mappedDrive + " was found, but is not a network drive. Were your network drives mapped correctly?");
            }
        }
    }

    if (!found)
    {
        throw new DirectoryNotFoundException("The drive " + mappedDrive + " was not found. Were your network drives mapped correctly?");
    }
    else
    {
        return serverName;
    }
}

Dies funktioniert für x64 Windows-7, für .NET 4. Es kann verwendet werden, im Falle, du bist immer, dass die Ausnahme, die oben erwähnt wurde.

Ich Tat dies mit den Sachen von MSDN und bits aus ibram ist oder Vermis' Antworten, aber es war ein bisschen schwer zu finden, konkrete Beispiele auf der MSDN-Website. Ressourcen:

MSDN : Win32_LogicalDisk-Klasse

MSDN : System.Management-namespace

MSDN : WMI-Abfragen Beispiel:

using System;
using System.Management;
class Query_SelectQuery
{
    public static int Main(string[] args) 
    {
        SelectQuery selectQuery = new 
            SelectQuery("Win32_LogicalDisk");
        ManagementObjectSearcher searcher =
            new ManagementObjectSearcher(selectQuery);

        foreach (ManagementObject disk in searcher.Get()) 
        {
            Console.WriteLine(disk.ToString());
        }

        Console.ReadLine();
        return 0;
    }
}

InformationsquelleAutor der Antwort Hydronium

Können Sie WMI, um die zu befragen, die Win32_LogicalDrive Sammlung auf Ihrem Computer. Hier ist ein Beispiel, wie es zu tun mit scripting. Ändern Sie diese über C# ist ziemlich gut erklärt, an anderen stellen.

Leicht modifiziert VB.NET code aus dem Artikel:

Public Class Form1

    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Dim strComputer = "."

        Dim objWMIService = GetObject("winmgmts:\\" & strComputer & "\root\cimv2")

        Dim colDrives = objWMIService.ExecQuery("Select * From Win32_LogicalDisk Where DriveType = 4")

        For Each objDrive In colDrives
            Debug.WriteLine("Drive letter: " & objDrive.DeviceID)
            Debug.WriteLine("Network path: " & objDrive.ProviderName)
        Next
    End Sub

End Class

InformationsquelleAutor der Antwort Nick

Können Sie auch die WMI verwenden, Win32_LogicalDisk, um alle Informationen, die Sie benötigen. verwenden der ProviderName aus der Klasse, um den UNC-Pfad.

InformationsquelleAutor der Antwort rerun

Soweit Windows das kümmert, was benötigt wird, ist ein Aufruf an WNetGetConnection. Ich weiß nicht, der ein front-end für die, die in .NET, so müssen Sie rufen es über P/Invoke (zum Glück, es hat nur einen parameter, den P/Invoke-code ist nicht zu schrecklich).

InformationsquelleAutor der Antwort Jerry Coffin