Ouverture d'un dossier dans l'explorateur et sélection d'un fichier

J'essaye d'ouvrir un dossier dans l'explorateur avec un fichier sélectionné.

Le code suivant produit une exception de fichier introuvable:

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

Comment puis-je exécuter cette commande en C #?

Utilisez cette méthode :

Process.Start(String, String)

Le premier argument est une application (explorer.exe), le second argument de méthode sont les arguments de l'application que vous exécutez.

Par exemple:

dans CMD:

explorer.exe -p

en 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 votre chemin contient des virgules, placer des guillemets autour du chemin fonctionnera lors de l'utilisation de Process.Start (ProcessStartInfo).

Cela ne fonctionnera PAS lors de l'utilisation de Process.Start (chaîne, chaîne). Il semble que Process.Start (string, string) supprime en fait les guillemets à l'intérieur de vos arguments.

Voici un exemple simple qui fonctionne pour moi.

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

Juste mes 2 cents, si votre nom de fichier contient des espaces, c'est-à-dire "c: \ Mon fichier contient des espaces.txt", vous devrez entourer le nom de fichier de guillemets, sinon l'explorateur supposera que les autres mots sont des arguments différents ...

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

La réponse de Samuel Yang m'a fait trébucher, voici ma valeur de 3 cents.

Adrian Hum a raison, assurez-vous de mettre des guillemets autour de votre nom de fichier. Non pas parce qu'il ne peut pas gérer les espaces comme l'a souligné Zourtney, mais parce qu'il reconnaîtra les virgules (et éventuellement d'autres caractères) dans les noms de fichiers comme des arguments séparés. Cela devrait donc ressembler à ce qu'Adrian Hum a suggéré.

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

L' utilisation Process.Startsur explorer.exele /selectraisonnement fonctionne curieusement que pour les chemins moins de 120 caractères.

J'ai dû utiliser une méthode Windows native pour que cela fonctionne dans tous les cas:

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

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

Notez qu'il devrait y avoir une virgule après / select au lieu d'un espace.

Vous devez mettre les arguments à passer ("/ select etc") dans le deuxième paramètre de la méthode Start.

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 raison la plus probable pour laquelle il ne trouve pas le fichier est le chemin contenant des espaces. Par exemple, il ne trouvera pas "explorer / select, c: \ space space \ space.txt".

Ajoutez simplement des guillemets avant et après le chemin, comme;

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

ou faites de même en C # avec

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

Cela peut être un peu exagéré, mais j'aime les fonctions de commodité, alors prenez celle-ci:

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

C'est la fonction d'extension que j'utilise comme <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;
    }
}