Öffnen Sie einen Ordner im Explorer und wählen Sie eine Datei aus

Ich versuche, einen Ordner im Explorer mit einer ausgewählten Datei zu öffnen.

Der folgende Code erzeugt eine Ausnahme für nicht gefundene Dateien:

System.Diagnostics.Process.Start(
    "explorer.exe /select," 
    + listView1.SelectedItems[0].SubItems[1].Text + "\\" 
    + listView1.SelectedItems[0].Text);

Wie kann ich diesen Befehl in C # ausführen lassen?

Verwenden Sie diese Methode :

Process.Start(String, String)

Das erste Argument ist eine Anwendung (explorer.exe), das zweite Methodenargument sind Argumente der von Ihnen ausgeführten Anwendung.

Beispielsweise:

in CMD:

explorer.exe -p

in C #:

Process.Start("explorer.exe", "-p")

// suppose that we have a test.txt at E:\
string filePath = @"E:\test.txt";
if (!File.Exists(filePath))
{
    return;
}

// combine the arguments together
// it doesn't matter if there is a space after ','
string argument = "/select, \"" + filePath +"\"";

System.Diagnostics.Process.Start("explorer.exe", argument);

Wenn Ihr Pfad Kommas enthält, funktioniert das Setzen von Anführungszeichen um den Pfad, wenn Sie Process.Start (ProcessStartInfo) verwenden.

Bei Verwendung von Process.Start (Zeichenfolge, Zeichenfolge) funktioniert dies jedoch NICHT. Es scheint, als würde Process.Start (Zeichenfolge, Zeichenfolge) tatsächlich die Anführungszeichen in Ihren Argumenten entfernen.

Hier ist ein einfaches Beispiel, das für mich funktioniert.

string p = @"C:\tmp\this path contains spaces, and,commas\target.txt";
string args = string.Format("/e, /select, \"{0}\"", p);

ProcessStartInfo info = new ProcessStartInfo();
info.FileName = "explorer";
info.Arguments = args;
Process.Start(info);

Nur mein Wert von 2 Cent. Wenn Ihr Dateiname Leerzeichen enthält, dh "c: \ Meine Datei enthält Leerzeichen.txt", müssen Sie den Dateinamen mit Anführungszeichen umgeben, da der Explorer sonst davon ausgeht, dass die anderen Wörter unterschiedliche Argumente sind ...

string argument = "/select, \"" + filePath +"\"";

Samuel Yang Antwort stolperte mich, hier ist meine 3 Cent wert.

Adrian Hum hat recht, stellen Sie sicher, dass Sie Ihren Dateinamen in Anführungszeichen setzen. Nicht weil es keine Leerzeichen verarbeiten kann, wie zourtney betont hat, sondern weil es die Kommas (und möglicherweise andere Zeichen) in Dateinamen als separate Argumente erkennt. So sollte es aussehen, wie Adrian Hum vorgeschlagen hat.

string argument = "/select, \"" + filePath +"\"";

Die Verwendung Process.Startauf explorer.exemit der/select Argument funktioniert seltsamerweise nur für Pfade mit einer Länge von weniger als 120 Zeichen.

Ich musste eine native Windows-Methode verwenden, damit sie in allen Fällen funktioniert:

[DllImport("shell32.dll", SetLastError = true)]
public static extern int SHOpenFolderAndSelectItems(IntPtr pidlFolder, uint cidl, [In, MarshalAs(UnmanagedType.LPArray)] IntPtr[] apidl, uint dwFlags);

[DllImport("shell32.dll", SetLastError = true)]
public static extern void SHParseDisplayName([MarshalAs(UnmanagedType.LPWStr)] string name, IntPtr bindingContext, [Out] out IntPtr pidl, uint sfgaoIn, [Out] out uint psfgaoOut);

public static void OpenFolderAndSelectItem(string folderPath, string file)
{
    IntPtr nativeFolder;
    uint psfgaoOut;
    SHParseDisplayName(folderPath, IntPtr.Zero, out nativeFolder, 0, out psfgaoOut);

    if (nativeFolder == IntPtr.Zero)
    {
        // Log error, can't find folder
        return;
    }

    IntPtr nativeFile;
    SHParseDisplayName(Path.Combine(folderPath, file), IntPtr.Zero, out nativeFile, 0, out psfgaoOut);

    IntPtr[] fileArray;
    if (nativeFile == IntPtr.Zero)
    {
        // Open the folder without the file selected if we can't find the file
        fileArray = new IntPtr[0];
    }
    else
    {
        fileArray = new IntPtr[] { nativeFile };
    }

    SHOpenFolderAndSelectItems(nativeFolder, (uint)fileArray.Length, fileArray, 0);

    Marshal.FreeCoTaskMem(nativeFolder);
    if (nativeFile != IntPtr.Zero)
    {
        Marshal.FreeCoTaskMem(nativeFile);
    }
}

Verwenden Sie "/select,c:\file.txt"

Beachten Sie, dass anstelle von Leerzeichen ein Komma nach / select stehen sollte.

Sie müssen die zu übergebenden Argumente ("/ select etc") in den zweiten Parameter der Start-Methode einfügen.

string windir = Environment.GetEnvironmentVariable("windir");
if (string.IsNullOrEmpty(windir.Trim())) {
    windir = "C:\\Windows\\";
}
if (!windir.EndsWith("\\")) {
    windir += "\\";
}    

FileInfo fileToLocate = null;
fileToLocate = new FileInfo("C:\\Temp\\myfile.txt");

ProcessStartInfo pi = new ProcessStartInfo(windir + "explorer.exe");
pi.Arguments = "/select, \"" + fileToLocate.FullName + "\"";
pi.WindowStyle = ProcessWindowStyle.Normal;
pi.WorkingDirectory = windir;

//Start Process
Process.Start(pi)

Der wahrscheinlichste Grund dafür, dass die Datei nicht gefunden wird, ist der Pfad mit Leerzeichen. Beispielsweise wird "explorer / select, c: \ space space \ space.txt" nicht gefunden.

Fügen Sie einfach doppelte Anführungszeichen vor und nach dem Pfad hinzu, z.

explorer /select,"c:\space space\space.txt"

oder machen Sie dasselbe in C # mit

System.Diagnostics.Process.Start("explorer.exe","/select,\"c:\space space\space.txt\"");

Es mag ein bisschen übertrieben sein, aber ich mag Convenience-Funktionen, also nimm diese:

    public static void ShowFileInExplorer(FileInfo file) {
        StartProcess("explorer.exe", null, "/select, "+file.FullName.Quote());
    }
    public static Process StartProcess(FileInfo file, params string[] args) => StartProcess(file.FullName, file.DirectoryName, args);
    public static Process StartProcess(string file, string workDir = null, params string[] args) {
        ProcessStartInfo proc = new ProcessStartInfo();
        proc.FileName = file;
        proc.Arguments = string.Join(" ", args);
        Logger.Debug(proc.FileName, proc.Arguments); // Replace with your logging function
        if (workDir != null) {
            proc.WorkingDirectory = workDir;
            Logger.Debug("WorkingDirectory:", proc.WorkingDirectory); // Replace with your logging function
        }
        return Process.Start(proc);
    }

Dies ist die Erweiterungsfunktion, die ich als <string> verwende. Quote ():

static class Extensions
{
    public static string Quote(this string text)
    {
        return SurroundWith(text, "\"");
    }
    public static string SurroundWith(this string text, string surrounds)
    {
        return surrounds + text + surrounds;
    }
}