Comment faire pour rediriger la sortie standard d'un projet C# de fichier à l'aide de Visual Studio “arguments de ligne de commande” option

Au sens strict, vous êtes obligé d'utiliser l'invite de commande pour démarrer le programme avec redirigé sortie. Sinon, vous devez analyser la ligne de commande vous-même, l'interface graphique shell peut pas le faire.

Si vous voulez juste pour rediriger la sortie lorsque vous Start Debugging, puis décochez la case à cocher de Enable the Visual Studio hosting process, vous avez terminé.

Si vous n'avez pas, et le "output.txt" vous avez vu il y a, en fait, est pas générées par votre application, mais "YourApplication.vshost.exe" qui est engendré avant de commencer à déboguer, par l'IDE de Visual Studio. Le contenu n'est toujours vide, et ne peut pas être écrit; car il est verrouillé par le Processus D'Hébergement.

Cependant, si vous souhaitez que l'application se comporte de la même quel que soit le mode de démarrage, les choses sont plus complexes.

Lorsque vous démarrer le débogage de l'application, il est lancé avec:

"YourApplication.exe" arg1 arg2

parce que la production est déjà redirigé par l'IDE.

Et quand vous Start Without Debugging, il est lancé avec:

"%comspec%" /c ""YourApplication.exe" arg1 arg2 ^>output.txt & pause"

C'est le bon moyen pour que votre application obtient tous les arguments que vous avez spécifié.

Vous pouvez avoir un coup d'oeil à ma réponse précédente de Comment puis-je détecter si "Appuyez sur n'importe quelle touche pour continuer . . ." s'affiche?.

Ici, je suis en utilisant une approche comme atavique retour dans le code ci-dessous:

• Code de l'application

  using System.Diagnostics;
  using System.Linq;
  using System;
  
  class Test {
      public static void Main(string[] args) {
          foreach(var arg in args)
              Console.WriteLine(arg);
      }
  
      static Test() {
          var current=Process.GetCurrentProcess();
          var parent=current.GetParentProcess();
          var grand=parent.GetParentProcess();
  
          if(null==grand
              ||grand.MainModule.FileName!=current.MainModule.FileName)
              using(var child=Process.Start(
                  new ProcessStartInfo {
                      FileName=Environment.GetEnvironmentVariable("comspec"),
                      Arguments="/c\x20"+Environment.CommandLine,
                      RedirectStandardOutput=true,
                      UseShellExecute=false
                  })) {
                  Console.Write(child.StandardOutput.ReadToEnd());
                  child.WaitForExit();
                  Environment.Exit(child.ExitCode);
              }
  #if false //change to true if child process debugging is needed 
          else {
              if(!Debugger.IsAttached)
                  Debugger.Launch();
  
              Main(Environment.GetCommandLineArgs().Skip(1).ToArray());
              current.Kill(); //or Environment.Exit(0); 
          }
  #endif
      }
  }

Nous avons également besoin de code suivant afin qu'il puisse fonctionner:

• Code des méthodes d'extension

  using System.Management; //add reference is required
  using System.Runtime.InteropServices;
  using System.Diagnostics;
  using System.Collections.Generic;
  using System.Linq;
  using System;
  public static partial class NativeMethods {
  [DllImport("kernel32.dll")]
  public static extern bool TerminateThread(
  IntPtr hThread, uint dwExitCode);
  [DllImport("kernel32.dll")]
  public static extern IntPtr OpenThread(
  uint dwDesiredAccess, bool bInheritHandle, uint dwThreadId);
  }
  public static partial class ProcessThreadExtensions /* public methods */ {
  public static void Abort(this ProcessThread t) {
  NativeMethods.TerminateThread(
  NativeMethods.OpenThread(1, false, (uint)t.Id), 1);
  }
  public static IEnumerable<Process> GetChildProcesses(this Process p) {
  return p.GetProcesses(1);
  }
  public static Process GetParentProcess(this Process p) {
  return p.GetProcesses(-1).SingleOrDefault();
  }
  }
  partial class ProcessThreadExtensions /* non-public methods */ {
  static IEnumerable<Process> GetProcesses(
  this Process p, int direction) {
  return
  from format in new[] { 
  "select {0} from Win32_Process where {1}" }
  let selectName=direction<0?"ParentProcessId":"ProcessId"
  let filterName=direction<0?"ProcessId":"ParentProcessId"
  let filter=String.Format("{0} = {1}", p.Id, filterName)
  let query=String.Format(format, selectName, filter)
  let searcher=new ManagementObjectSearcher("root\\CIMV2", query)
  from ManagementObject x in searcher.Get()
  let process=
  ProcessThreadExtensions.GetProcessById(x[selectName])
  where null!=process
  select process;
  }
  //not a good practice to use generics like this; 
  //but for the convenience .. 
  static Process GetProcessById<T>(T processId) {
  try {
  var id=(int)Convert.ChangeType(processId, typeof(int));
  return Process.GetProcessById(id);
  }
  catch(ArgumentException) {
  return default(Process);
  }
  }
  }

Depuis le parent serait IDE de Visual Studio(actuellement nommé "devenv") lorsque nous avons le débogage. Les parents et les processus, en fait, sont divers, et nous aurions besoin d'une règle pour effectuer quelques vérifications.

La partie la plus délicate est que l'enfant est celui qui fonctionne vraiment dans Main. Le code de vérification pour les grands-parents de processus chaque fois qu'il exécute. Si les grands-parents est null alors qu'il engendre, mais le processus engendré serait %comspec%, qui est également la mère du nouveau processus, il va commencer avec le même exécutable de courant. Ainsi, si les grands-parents sont les mêmes que lui-même, alors il ne pourra pas continuer à frayer, passe juste en Main.

La Constructeur Statique est utilisé dans le code, qui est commencé avant Main. Il est répondu à la question sur DONC: Comment un constructeur statique de travail?.

Lorsque nous avons commencer à déboguer, nous sommes le débogage des grands-parents(qui engendre). Pour le débogage avec le petit-fils de processus, j'ai fait Debugger.Launch avec une compilation conditionnelle qui invoquera Main, pour garder Main clair.

Une répondu à la question sur le débogueur serait également utile: Attacher le débogueur en C# pour un autre processus.

Dans la section Options de Démarrage, le changement de vos arguments de ligne de commande zone de texte de cette façon

args1 args2 1>output.txt

Cette redirige la sortie standard (1) création d'un fichier nommé output.txt

Si vous voulez ajouter à une version précédente du fichier en écriture

args1 args2 1>>output.txt

Maintenant, vous pouvez déboguer le programme étape par Étape, tandis que la sortie de la console est redirigé

Vous pouvez ouvrir le .csproj.user dans un éditeur externe et modifier le StartArguments à partir de:

<StartArguments>arg1 arg2 &gt; output.txt</StartArguments>

à

<StartArguments>arg1 arg2 > output.txt</StartArguments>

La manière la plus simple est:
Clic droit sur le Projet => Propriétés ==> Debug

Et assurez-vous d'exécuter votre programme dans mode Debug.