En Direct de la sortie du Processus

Prendre un coup d'oeil à cette page, il recherche c'est la solution pour vous: http://msdn.microsoft.com/en-us/library/system.diagnostics.process.beginoutputreadline.aspx et http://msdn.microsoft.com/en-us/library/system.diagnostics.process.standardoutput.aspx

[Modifier]
C'est un exemple de travail:

        Process p = new Process();
        p.StartInfo.RedirectStandardError = true;
        p.StartInfo.RedirectStandardOutput = true;
        p.StartInfo.UseShellExecute = false;
        p.StartInfo.CreateNoWindow = true;
        p.StartInfo.FileName = @"C:\Program Files (x86)\gnuwin32\bin\ls.exe";
        p.StartInfo.Arguments = "-R C:\\";

        p.OutputDataReceived += new DataReceivedEventHandler((s, e) => 
        { 
            Console.WriteLine(e.Data); 
        });
        p.ErrorDataReceived += new DataReceivedEventHandler((s, e) =>
        {
            Console.WriteLine(e.Data);
        });

        p.Start();
        p.BeginOutputReadLine();
        p.BeginErrorReadLine();

Btw, ls -R C:\ répertorie tous les fichiers à la racine de C: de manière récursive. Il y a beaucoup de fichiers, et je suis sûr que ce n'est pas le cas lorsque les premiers résultats apparaissent à l'écran.
Il y a une possibilité 7zip contient la sortie avant de le montrer. Je ne suis pas sûr de ce que params vous donner à ce processus.

Je ne sais pas si quelqu'un est toujours à la recherche d'une solution à cela, mais il est venu à plusieurs reprises pour moi parce que je suis en train d'écrire un outil dans l'Unité à l'appui de certains jeux et en raison de la faible interopérabilité de certains systèmes mono (comme PIA pour la lecture de texte à partir de Word, par exemple), j'ai souvent à écrire des OS (parfois, Windows, parfois MacOS) exécutables et les lancer à partir de Processus.Start().

Le problème est, quand vous lancer un fichier exécutable comme cela, il va tirer dans un autre thread qui bloque votre application principale, provoquant un blocage. Si vous souhaitez fournir une rétroaction utile pour vos utilisateurs pendant ce temps, au-delà de la filature icônes imaginé par votre système d'exploitation, alors vous êtes le genre de baiser. À l'aide d'un flux ne fonctionne pas parce que le fil est toujours bloqué jusqu'à l'exécution des finitions.

La solution que j'ai frappé à, ce qui peut sembler extrême pour certaines personnes, mais je trouve fonctionne très bien pour moi, est d'utiliser les sockets et le multithreading pour définir fiables de manière synchrone les communications entre les deux applications. Bien sûr, cela ne fonctionne que si vous êtes à la création de deux applications. Si non, je pense que vous êtes hors de la chance. ... Je voudrais voir si il fonctionne seulement avec le multithreading, à l'aide d'un traditionnel flux approche, donc si quelqu'un veut essayer et poster les résultats ici, ce serait génial.

De toute façon, voici la solution actuellement en train de travailler pour moi:

Dans la main, ou en appelant à l'application, je fais quelque chose comme ceci:

///<summary>
///Handles the OK button click.
///</summary>
private void HandleOKButtonClick() {
string executableFolder = "";

#if UNITY_EDITOR
executableFolder = Path.Combine(Application.dataPath, "../../../../build/Include/Executables");
#else
executableFolder = Path.Combine(Application.dataPath, "Include/Executables");
#endif

EstablishSocketServer();

var proc = new Process {
    StartInfo = new ProcessStartInfo {
        FileName = Path.Combine(executableFolder, "WordConverter.exe"),
        Arguments = locationField.value + " " + _ipAddress.ToString() + " " + SOCKET_PORT.ToString(), 
        UseShellExecute = false,
        RedirectStandardOutput = true,
        CreateNoWindow = true
    }
};

proc.Start();

Voici où j'ai établir le serveur socket:

///<summary>
///Establishes a socket server for communication with each chapter build script so we can get progress updates.
///</summary>
private void EstablishSocketServer() {
    //_dialog.SetMessage("Establishing socket connection for updates. \n");
    TearDownSocketServer();

    Thread currentThread;

    _ipAddress = Dns.GetHostEntry(Dns.GetHostName()).AddressList[0];
    _listener = new TcpListener(_ipAddress, SOCKET_PORT);
    _listener.Start();

    UnityEngine.Debug.Log("Server mounted, listening to port " + SOCKET_PORT);

    _builderCommThreads = new List<Thread>();

    for (int i = 0; i < 1; i++) {
        currentThread = new Thread(new ThreadStart(HandleIncomingSocketMessage));
        _builderCommThreads.Add(currentThread);
        currentThread.Start();
    }
}

///<summary>
///Tears down socket server.
///</summary>
private void TearDownSocketServer() {
    _builderCommThreads = null;

    _ipAddress = null;
    _listener = null;
}

Voici mon socket gestionnaire pour le fil... notez que vous devrez créer plusieurs threads dans certains cas; c'est pourquoi j'ai que _builderCommThreads Liste de là (je l'ai porté sous de code ailleurs, là où je faisais quelque chose de similaire, mais l'appel de plusieurs instances dans une rangée):

///<summary>
///Handles the incoming socket message.
///</summary>
private void HandleIncomingSocketMessage() {
if (_listener == null) return;
while (true) {
Socket soc = _listener.AcceptSocket();
//soc.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 10000);
NetworkStream s = null;
StreamReader sr = null;
StreamWriter sw = null;
bool reading = true;
if (soc == null) break;
UnityEngine.Debug.Log("Connected: " + soc.RemoteEndPoint);
try {
s = new NetworkStream(soc);
sr = new StreamReader(s, Encoding.Unicode);
sw = new StreamWriter(s, Encoding.Unicode);
sw.AutoFlush = true; //enable automatic flushing
while (reading == true) {
string line = sr.ReadLine();
if (line != null) {
//UnityEngine.Debug.Log("SOCKET MESSAGE: " + line);
UnityEngine.Debug.Log(line);
lock (_threadLock) {
//Do stuff with your messages here
}
}
}
//
} catch (Exception e) {
if (s != null) s.Close();
if (soc != null) soc.Close();
UnityEngine.Debug.Log(e.Message);
//return;
} finally {
//
if (s != null) s.Close();
if (soc != null) soc.Close();
UnityEngine.Debug.Log("Disconnected: " + soc.RemoteEndPoint);
}
}
return;
}

Bien sûr, vous aurez besoin de déclarer certains trucs en haut:

private TcpListener _listener = null;
private IPAddress _ipAddress = null;
private List<Thread> _builderCommThreads = null;
private System.Object _threadLock = new System.Object();

...puis dans le invoquée exécutable, mis en place l'autre extrémité (j'ai utilisé de la statique dans ce cas, vous pouvez utiliser ce que jamais vous le souhaitez):

private static TcpClient _client = null;
private static Stream _s = null;
private static StreamReader _sr = null;
private static StreamWriter _sw = null;
private static string _ipAddress = "";
private static int _port = 0;
private static System.Object _threadLock = new System.Object();
///<summary>
///Main method.
///</summary>
///<param name="args"></param>
static void Main(string[] args) {
try {
if (args.Length == 3) {
_ipAddress = args[1];
_port = Convert.ToInt32(args[2]);
EstablishSocketClient();
}
//Do stuff here
if (args.Length == 3) Cleanup();
} catch (Exception exception) {
//Handle stuff here
if (args.Length == 3) Cleanup();
}
}
///<summary>
///Establishes the socket client.
///</summary>
private static void EstablishSocketClient() {
_client = new TcpClient(_ipAddress, _port);
try {
_s = _client.GetStream();
_sr = new StreamReader(_s, Encoding.Unicode);
_sw = new StreamWriter(_s, Encoding.Unicode);
_sw.AutoFlush = true;
} catch (Exception e) {
Cleanup();
}
}
///<summary>
///Clean up this instance.
///</summary>
private static void Cleanup() {
_s.Close();
_client.Close();
_client = null;
_s = null;
_sr = null;
_sw = null;
}
///<summary>
///Logs a message for output.
///</summary>
///<param name="message"></param>
private static void Log(string message) {
if (_sw != null) {
_sw.WriteLine(message);
} else {
Console.Out.WriteLine(message);
}
}

...Je suis en utilisant ce de lancer un outil en ligne de commande sur Windows qui utilise le PIA trucs à extraire du texte d'un document Word. J'ai essayé le PIA .dll dans l'Unité, mais a couru dans l'interopérabilité des problèmes avec mono. Je suis également de l'utiliser sur MacOS pour appeler des scripts shell de lancement supplémentaire de l'Unité des instances dans batchmode et exécutez l'éditeur de scripts dans ces instances qui de parler de retour de l'outil au cours de cette connexion de socket. C'est génial, parce que je peux maintenant envoyer des commentaires à l'utilisateur, de débogage, de surveiller et de répondre à des étapes précises du processus, et cetera, et cetera.

HTH

De l'essayer.

        Process notePad = new Process();
notePad.StartInfo.FileName = "7z.exe";
notePad.StartInfo.RedirectStandardOutput = true;
notePad.StartInfo.UseShellExecute = false;
notePad.Start();
StreamReader s = notePad.StandardOutput;
String output= s.ReadToEnd();
notePad.WaitForExit();

Laissez-le au-dessus de l'être dans un thread.

Maintenant pour la mise à jour de la sortie de l'INTERFACE utilisateur,vous pouvez utiliser un timer avec deux lignes

  Console.Clear();
Console.WriteLine(output);

Cela peut vous aider à