L'application a commencé par processus.Start () ne reçoit pas d'arguments

Question

Utilisation C #, j'essaie de passer des arguments de ligne de commande à un nouveau processus à l'aide de processus.Start ():

string path = @"C:\Demo\Demo.exe";
string arguments = "one two three";
ProcessStartInfo startInfo = new ProcessStartInfo
   {
      FileName = path,
      Arguments = arguments
   };
var process = Process.Start(startInfo);

mon application C Demo.exe Il suffit d'echos les arguments de la ligne de commande:

int main( int argc, char *argv[] )
{
   int count=0;

   // Display each command-line argument.
    printf( "\nCommand-line arguments:\n" );
    for( count = 0; count < argc; count++ )
        printf( "  argv[%d]   %s\n", count, argv[count] );

    while(1);
}

Si je démarre mon application de cmd.exe, je reçois une sortie raisonnable:

Command-line arguments:
 argv[0]   Demo.exe
 argv[1]   one
 argv[2]   two
 argv[3]   three

Lorsque j'utilise l'application C #, la seule chose que je reçois est l'argument de chemin sur argv [0]:

Command-line arguments:
  argv[0]   C:

Task Manager affiche les arguments de ligne de commande pour chaque méthode de démarrage de Demo.exe:

Pourquoi mon application C n'est-elle pas recevant les arguments de ligne de commande de l'application C #?

Modifier @HVD a suggéré d'utiliser GeCommandLine (). Voici le code et le résultat de celui-ci:

char* ar = GetCommandLine();
printf( "\nGetCommandLine arguments:\n" );
printf("  %s", ar);

sortie:

GetCommandLine arguments:
  "C:

est-il possible que l'application C reçoit les arguments comme une chaîne, mais ignore tout après le premier \ dans le chemin?

EDIT: J'ai ajouté une réponse ci-dessous. C'est une solution de contournement, mais je ne suis pas sûr de la cause de mon problème.

Answer 1

J'ai pu reproduire votre problème. Je n'avais pas accès à C, donc j'ai utilisé C ++ dans Visual Studio 2013. Il apparaît que c # à l'aide de startinfo passe les arguments comme des caractères unicode , donc le premier octet est donc le premier octet Non-zéro, tandis que le 2e octet est probable 0 bits entraînant l'affichage du premier caractère car cela indique le caractère de terminaison de chaîne. Quand j'ai utilisé Printf, il n'a pas fonctionné, je devais utiliser _TPrintf pour voir ce qui est passé. Et printf ne gère pas Unicode . Non seulement Printf ne le gère pas, votre programme C lorsqu'il remplissait argv ne traduira pas unicode à une chaîne à l'aide de 1 caractères d'octets. Tandis que TCHAR (chargé de chargement) et TPRINTF en C ++, de même que C # Nativement.

Alors, lorsque vous l'avez fait l'inverse, en utilisant "cmd.exe" à appeler "/ c demio.exe un deux trois" cmd n'était pas en train de passer la chaîne comme Unicode . C'est mon hypothèse, compte tenu des résultats que je reçois.

question connexe sur Stackoverflow

• Process.Startinfo.arguments prend en charge un UTF-8 chaîne?

Le code C ++ qui affichait les arguments correctement (TPRINTF) et incorrectement (printf)

#include "stdafx.h"
#include "string.h"

int _tmain(int argc, _TCHAR* argv[])
{
    int count=0;

    // Display each command-line argument.
    printf( "\nCommand-line arguments:\n" );
    for( count = 0; count < argc; count++ )
        //Correct. This statement worked, displaying the arguments
        //_tprintf( _T("  argv[%d]   %s\n"), count, argv[count] );

        //Incorrect. Displayed only the first character of each argument
        //printf( "  argv[%d]   %s\n", count, argv[count] );

getchar();
return 0;

}

Ceci est le code C # qui l'a appelé

namespace ProcessPassArguments
{
    class Program
    {
        static void Main(string[] args)
        {
            string path = @"C:\Temp\Demo.exe";
                    string arguments = "one two three";
            ProcessStartInfo startInfo = new ProcessStartInfo
            {
                FileName = path,
                Arguments = arguments
            };
            var process = Process.Start(startInfo);
        }
    }
}

À des fins d'information uniquement, c # appelant le C # a également fonctionné. Encore une fois, la cause soupçonnée est que c # transmet les arguments à votre programme C sous la forme unicode .

Le code C # qui fonctionne comme la cible programmée appelée.

namespace Demo
{
    class Program
    {
        static void Main(string[] args)
        {
            int i = 0;
            foreach (string arg in args)
            {
                i++;
                Console.WriteLine("Argument {0}: {1}", i, arg);
            }
            Console.ReadLine();
        }

    }
}

Answer 2

Je suis retourné à cela aujourd'hui et j'ai une solution de contournement.Je ne comprends pas pourquoi ma tentative initiale n'a pas fonctionné.

Voici la différence sur la ligne de commande entre taper Demo.exe et "Demo.exe."

C:\Users\me\Desktop\Work\Builds\Win32>Demo.exe one two three
There are 4 arguments.
Command-line arguments:
argv[0]: Demo.exe
argv[1]: one
argv[2]: two
argv[3]: three

C:\Users\me\Desktop\Work\Builds\Win32>"Demo.exe" one two three
There are 1 arguments.
Command-line arguments:
argv[0]: Demo.exe

L'appel process.Start () semblait faire la variété "Demo.exe".

ne fonctionne pas:

ProcessStartInfo startInfo = new ProcessStartInfo
{
   FileName = @"Demo.exe",
   WorkingDirectory = @"C:\Users\me\Desktop\Work\Builds\Win32",
   Arguments = "one two three"
 };
 var process = Process.Start(startInfo);

There are 1 arguments.
Command-line arguments:
argv[0]: C:

fonctionne:

ProcessStartInfo startInfo = new ProcessStartInfo
{
   FileName = "cmd.exe",
   WorkingDirectory = @"C:\Users\me\Desktop\Work\Builds\Win32",
   Arguments = "/C Demo.exe one two three"
 };
 var process = Process.Start(startInfo);
There are 4 arguments.
Command-line arguments:
argv[0]: Demo.exe
argv[1]: one
argv[2]: two
argv[3]: three

Quelqu'un a-t-il des idées pourquoi la première méthode ne fonctionne pas?

Answer 3

Essayez ceci

Arguments = "\"arg1\" \"arg2\" \"arg3\"";