Abrir una carpeta en el explorador y seleccionar un archivo

Estoy tratando de abrir una carpeta en el explorador con un archivo seleccionado.

El siguiente código produce una excepción de archivo no encontrado:

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

¿Cómo puedo hacer que este comando se ejecute en C #?

Usa este método :

Process.Start(String, String)

El primer argumento es una aplicación (explorer.exe), el segundo argumento del método son argumentos de la aplicación que ejecuta.

Por ejemplo:

en CMD:

explorer.exe -p

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

Si su ruta contiene comas, poner comillas alrededor de la ruta funcionará cuando use Process.Start (ProcessStartInfo).

Sin embargo, NO funcionará cuando se use Process.Start (string, string). Parece que Process.Start (string, string) en realidad elimina las comillas dentro de sus argumentos.

Aquí hay un ejemplo simple que funciona para mí.

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

Solo mi valor de 2 centavos, si su nombre de archivo contiene espacios, es decir, "c: \ Mi archivo contiene espacios.txt", deberá rodear el nombre del archivo con comillas; de lo contrario, el explorador asumirá que las otras palabras son argumentos diferentes ...

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

La respuesta de Samuel Yang me hizo tropezar, aquí valen mis 3 centavos.

Adrian Hum tiene razón, asegúrese de poner comillas alrededor de su nombre de archivo. No porque no pueda manejar espacios como señaló Zourtney, sino porque reconocerá las comas (y posiblemente otros caracteres) en los nombres de archivos como argumentos separados. Entonces debería verse como sugirió Adrian Hum.

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

El uso Process.Startde explorer.exela /selectargumentación curiosamente sólo funciona para las rutas de menos de 120 caracteres de longitud.

Tuve que usar un método nativo de Windows para que funcione en todos los casos:

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

Use "/select,c:\file.txt"

Observe que debe haber una coma después / select en lugar de espacio.

Debe colocar los argumentos para pasar ("/ select, etc") en el segundo parámetro del método de Inicio.

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)

La razón más posible para que no encuentre el archivo es la ruta que tiene espacios. Por ejemplo, no encontrará "explorer / select, c: \ space space \ space.txt".

Simplemente agregue comillas dobles antes y después de la ruta, como;

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

o hacer lo mismo en C # con

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

Puede ser un poco exagerado, pero me gustan las funciones de conveniencia, así que toma esta:

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

Esta es la función de extensión que uso como <string> .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;
    }
}