N'Processus.StartInfo.Nom de fichier accepter les noms de fichier longs?

À reproduire votre problème, j'ai utilisé le programme suivant:

//file test.cs
using System;
using System.ComponentModel;
using System.Diagnostics;

public class Test
{
    public static int Main()
    {
        string error;
        try {
            ProcessStartInfo i = new ProcessStartInfo();
            i.FileName = @"C:\long file path\run.cmd";
            i.WindowStyle = ProcessWindowStyle.Hidden;
            i.UseShellExecute = true;
            i.RedirectStandardOutput = false;
            using (Process p = Process.Start(i)) {
                error = "No process object was returned from Process.Start";
                if (p != null) {
                    p.WaitForExit();
                    if (p.ExitCode == 0) {
                        Console.ForegroundColor = ConsoleColor.Green;
                        Console.WriteLine("OK");
                        Console.ResetColor();
                        return 0;
                    }
                    error = "Process exit code was " + p.ExitCode;
                }
            }
        }
        catch (Win32Exception ex) {
            error = "(Win32Exception) " + ex.Message;
        }
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine("Whooops: " + error);
        Console.ResetColor();
        return 1;
    }
}

Le code commence un nouveau processus (comme par votre exemple de code) et les rapports sur les différentes façons dont il peut ne pas s'exécuter. Vous pouvez compiler le programme en ligne de commande:

c:\windows\Microsoft.NET\Framework\v2.0.50727\csc test.cs

(en supposant que le test.cs est dans le répertoire courant; il permettra de créer des test.exe dans le même répertoire que le test.cs)

Comme prévu, lors de l' "C:\long chemin d'accès du fichier\run.cmd" n'existe pas, le programme ne parvient pas à:

Whooops: (Win32Exception) The system cannot find the file specified

Maintenant, nous allons créer un répertoire "C:\long chemin d'accès au fichier" et de mettre un très simple à exécuter.cmd dans:

rem file run.cmd
echo I ran at %Time% > "%~dp0\run.out.txt"

Cependant, à ce point, j'ai été incapable de reproduire votre échec. Une fois le au-dessus de l'exécuter.cmd est en place, test.exe s'exécute correctement (c'est à dire exécuter.cmd est exécutée correctement, vous pouvez vérifier cela en regardant un fichier nouvellement créé "C:\long fichier path\run.out.txt".

J'ai couru test.exe sur Vista x64 (mon principal dev machine), Windows XP SP3 x86 (machine virtuelle), Windows Server 2008 x64 (machine virtuelle) et il fonctionne partout.

Pourriez-vous essayer d'exécuter le code ci-dessus dans votre environnement et de votre rapport si c'est un échec pour vous? De cette façon, nous permettra au moins de mettre en place le même cadre test (de même .NET programme sera d'essayer d'exécuter le même fichier de commandes dans le même endroit, pour vous comme pour moi).

OriginalL'auteur Milan Gardian

Je suis incapable de reproduire le comportement que vous décrivez. Le code suivant fonctionne pour moi.

string path = @"X:\Temp\long file path\run.cmd";
Process p = new Process();
p.StartInfo.FileName = path;

//Works with both true (default) and false.
p.StartInfo.UseShellExecute = true;
p.Start();

modifier

Je suis en mesure de reproduire avec le code suivant

  string path = @"X:\Temp\long file path";
  string file = "run.cmd";

  Process p = new Process();
  p.StartInfo.FileName = file;
  p.StartInfo.WorkingDirectory = path;
  p.StartInfo.UseShellExecute = false; //only fails with false.
  p.Start();
  return;

Ce spectacle (avec Process Monitor) ConsoleApplication.vshost.exe essaie de trouver l'exécuter.cmd dans le projet\bin\Release, System32, Système, Windows, System32\Wbem, et puis encore en certains (je suppose) variables de chemin d'accès. Il fonctionne, cependant, si j'ai mis UseShellExecute = true.

OriginalL'auteur sisve

Essayer

runScripts.StartInfo.FileName = @"""C:\long file path\run.cmd""";

Bien que j'étais sûr que c'était fait automatiquement pour vous par la classe de Processus. Êtes-vous sûr de fournir le chemin d'accès correct?

OriginalL'auteur Alex Reitbort

(Mise à jour)

Je pense que j'ai trouvé le problème de l'ingénierie inverse le Processus.Méthode de démarrage un peu plus. J'ai été dans le bon sens, il échoue sans avoir un WorkingDirectory ensemble.

Donc, en d'autres mots CreateProcess besoin d'une adresse workingdirectory, pas .NET (il faut vraiment le deviner à partir du nom de fichier, mais n'a évidemment pas)

En voici la preuve:

namespace SoTest
{
class Program
{
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
public static extern bool CreateProcess([MarshalAs(UnmanagedType.LPTStr)] string lpApplicationName, StringBuilder lpCommandLine, SECURITY_ATTRIBUTES lpProcessAttributes, SECURITY_ATTRIBUTES lpThreadAttributes, bool bInheritHandles, int dwCreationFlags, IntPtr lpEnvironment, [MarshalAs(UnmanagedType.LPTStr)] string lpCurrentDirectory, STARTUPINFO lpStartupInfo, PROCESS_INFORMATION lpProcessInformation);
static void Main(string[] args)
{
Process process = new Process();
process.StartInfo.FileName = @"C:\my test folder\my test.bat";
StringBuilder cmdLine = new StringBuilder();
cmdLine.Append(process.StartInfo.FileName);
STARTUPINFO lpStartupInfo = new STARTUPINFO();
PROCESS_INFORMATION lpProcessInformation = new PROCESS_INFORMATION();
//This fails
//string workingDirectory = process.StartInfo.WorkingDirectory;
string workingDirectory = @"C:\my test folder\";
CreateProcess(null, cmdLine, null, null, true, 0, IntPtr.Zero, workingDirectory, lpStartupInfo, lpProcessInformation);
}
}
[StructLayout(LayoutKind.Sequential)]
internal class PROCESS_INFORMATION
{
public IntPtr hProcess;
public IntPtr hThread;
public int dwProcessId;
public int dwThreadId;
public PROCESS_INFORMATION()
{
this.hProcess = IntPtr.Zero;
this.hThread = IntPtr.Zero;
}
}
[StructLayout(LayoutKind.Sequential)]
internal class SECURITY_ATTRIBUTES
{
public int nLength;
public long lpSecurityDescriptor;
public bool bInheritHandle;
}
[StructLayout(LayoutKind.Sequential)]
internal class STARTUPINFO
{
public int cb;
public IntPtr lpReserved;
public IntPtr lpDesktop;
public IntPtr lpTitle;
public int dwX;
public int dwY;
public int dwXSize;
public int dwYSize;
public int dwXCountChars;
public int dwYCountChars;
public int dwFillAttribute;
public int dwFlags;
public short wShowWindow;
public short cbReserved2;
public IntPtr lpReserved2;
public IntPtr hStdInput;
public IntPtr hStdOutput;
public IntPtr hStdError;
public STARTUPINFO()
{
this.lpReserved = IntPtr.Zero;
this.lpDesktop = IntPtr.Zero;
this.lpTitle = IntPtr.Zero;
this.lpReserved2 = IntPtr.Zero;
this.hStdInput = IntPtr.Zero;
this.hStdOutput = IntPtr.Zero;
this.hStdError = IntPtr.Zero;
this.cb = Marshal.SizeOf(this);
}
}       
}

J'ai supprimé SafeFileHandle à partir du code original car il n'était pas nécessaire pour ce que nous faisons. Aussi ne commencer les drapeaux ont été mis en, mais elles sont nécessaires pour une version sans fenêtre.

OriginalL'auteur Chris S

Votre code peut échouer pour diverses raisons qui sont sans rapport avec le "long/short" problème de chemin d'accès. Vous devez ajouter l'exacte description de l'exception (y compris la pile d'appel) à votre question.

OriginalL'auteur Igor Brejc