ProcessBuilder Classe

Definizione

Spazio dei nomi:

Java.Lang

Assembly:

Mono.Android.dll

Questa classe viene usata per creare processi del sistema operativo.

[Android.Runtime.Register("java/lang/ProcessBuilder", DoNotGenerateAcw=true)]
public sealed class ProcessBuilder : Java.Lang.Object

[<Android.Runtime.Register("java/lang/ProcessBuilder", DoNotGenerateAcw=true)>]
type ProcessBuilder = class
    inherit Object

Ereditarietà

Object

Object

ProcessBuilder

Attributi

RegisterAttribute

Commenti

Questa classe viene usata per creare processi del sistema operativo.

Ogni ProcessBuilder istanza gestisce una raccolta di attributi di processo. Il #start() metodo crea una nuova Process istanza con tali attributi. Il #start() metodo può essere richiamato ripetutamente dalla stessa istanza per creare nuovi sottoprocessi con attributi identici o correlati.

Ogni generatore di processi gestisce questi attributi di processo:

<ul>

<li>a command, un elenco di stringhe che indica il file di programma esterno da richiamare e i relativi argomenti, se presente. Quali elenchi di stringhe rappresentano un comando del sistema operativo valido dipende dal sistema. Ad esempio, è comune che ogni argomento concettuale sia un elemento in questo elenco, ma esistono sistemi operativi in cui i programmi devono tokenizzare le stringhe della riga di comando. In tale sistema un'implementazione Java potrebbe richiedere comandi per contenere esattamente due elementi.

<li>un ambiente, ovvero un mapping dipendente dal sistema dalle variabili ai valori. Il valore iniziale è una copia dell'ambiente del processo corrente (vedere System#getenv()).

<li>una directory di lavoro. Il valore predefinito è la directory di lavoro corrente del processo corrente, in genere la directory denominata dalla proprietà user.dirdi sistema .

<li>"redirect-input">un'origine di <input/i>> standard<. Per impostazione predefinita, il subprocesso legge l'input da una pipe. Il codice Java può accedere a questa pipe tramite il flusso di output restituito da Process#getOutputStream(). Tuttavia, l'input standard può essere reindirizzato a un'altra origine usando #redirectInput(Redirect) redirectInput. In questo caso, Process#getOutputStream() restituirà un flusso di output Null, per cui:

<ul><li>i OutputStream#write(int) write metodi generano IOException<sempre li>il OutputStream#close() close metodo non fa nulla </ul>

<li>"redirect-output">a destination for <i>standard output</i> and <i standard error</i>>. Per impostazione predefinita, il subprocesso scrive l'output standard e l'errore standard in pipe. Il codice Java può accedere a queste pipe tramite i flussi di input restituiti da Process#getInputStream() e Process#getErrorStream(). Tuttavia, l'output standard e l'errore standard possono essere reindirizzati ad altre destinazioni usando #redirectOutput(Redirect) redirectOutput e #redirectError(Redirect) redirectError. In questo caso, Process#getInputStream() e/o Process#getErrorStream() restituirà un flusso di input Null, per cui:

<ul><li>i InputStream#read() read metodi restituiscono -1<sempre li il InputStream#available() available metodo restituisce<0 sempre li>>il InputStream#close() close metodo non fa nulla </ul>

<li>una proprietà redirectErrorStream . Inizialmente, questa proprietà è false, significa che l'output standard e l'output degli errori di un subprocesso vengono inviati a due flussi separati, a cui è possibile accedere usando i Process#getInputStream() metodi e Process#getErrorStream() .

Se il valore è impostato su true, allora:

<ul><li standard error viene unito all'output standard e viene sempre inviato alla stessa destinazione (in questo modo è più semplice correlare i messaggi di errore con l'output corrispondente) <li>>la destinazione comune dell'errore standard e l'output standard può essere reindirizzato usando<#redirectOutput(Redirect) redirectOutput li>qualsiasi reindirizzamento impostato dal #redirectError(Redirect) redirectError metodo viene ignorato quando si crea un sottoprocesso <li>il flusso restituito da Process#getErrorStream() sarà sempre un flusso< di input Null/ul>

</ul>

La modifica degli attributi di un generatore di processi influisce sui processi avviati successivamente dal metodo dell'oggetto #start() , ma non influisce mai sui processi avviati in precedenza o sul processo Java stesso.

La maggior parte dei #start() controlli degli errori viene eseguita dal metodo . È possibile modificare lo stato di un oggetto in modo che non #start() riesca. Ad esempio, l'impostazione dell'attributo di comando su un elenco vuoto non genererà un'eccezione a meno che #start() non venga richiamata.

<nota forte>che questa classe non è sincronizzata.</strong> Se più thread accedono simultaneamente a un'istanza ProcessBuilder e almeno uno dei thread modifica uno degli attributi in modo strutturale, deve essere sincronizzato esternamente.

L'avvio di un nuovo processo che usa la directory di lavoro predefinita e l'ambiente è semplice:

{@code
            Process p = new ProcessBuilder("myCommand", "myArg").start();
            }

Ecco un esempio che avvia un processo con una directory di lavoro e un ambiente di lavoro modificato e reindirizza l'output e l'errore standard da aggiungere a un file di log:

{@code
            ProcessBuilder pb =
              new ProcessBuilder("myCommand", "myArg1", "myArg2");
            Map<String, String> env = pb.environment();
            env.put("VAR1", "myValue");
            env.remove("OTHERVAR");
            env.put("VAR2", env.get("VAR1") + "suffix");
            pb.directory(new File("myDir"));
            File log = new File("log");
            pb.redirectErrorStream(true);
            pb.redirectOutput(Redirect.appendTo(log));
            Process p = pb.start();
            assert pb.redirectInput() == Redirect.PIPE;
            assert pb.redirectOutput().file() == log;
            assert p.getInputStream().read() == -1;
            }

Per avviare un processo con un set esplicito di variabili di ambiente, prima java.util.Map#clear() Map.clear() di aggiungere variabili di ambiente.

Aggiunto nella versione 1.5.

Documentazione Java per java.lang.ProcessBuilder.

Le parti di questa pagina sono modifiche in base al lavoro creato e condiviso dal Android Open Source e usato in base ai termini descritti nella .

Costruttori

ProcessBuilder(IList<String>)	Costruisce un generatore di processi con il programma e gli argomenti del sistema operativo specificati.
ProcessBuilder(String[])	Costruisce un generatore di processi con il programma e gli argomenti del sistema operativo specificati.

Proprietà

Class	Restituisce la classe di runtime di questo Objectoggetto . (Ereditato da Object)
Handle	Handle all'istanza di Android sottostante. (Ereditato da Object)
JniIdentityHashCode	Questa classe viene usata per creare processi del sistema operativo. (Ereditato da Object)
JniPeerMembers	Questa classe viene usata per creare processi del sistema operativo.
PeerReference	Questa classe viene usata per creare processi del sistema operativo. (Ereditato da Object)
ThresholdClass	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice. (Ereditato da Object)
ThresholdType	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice. (Ereditato da Object)

Metodi

Clone()	Crea e restituisce una copia di questo oggetto. (Ereditato da Object)
Command()	Restituisce il programma e gli argomenti del sistema operativo del generatore di processi.
Command(IList<String>)	Imposta il programma e gli argomenti del sistema operativo del generatore di processi.
Command(String[])	Restituisce il programma e gli argomenti del sistema operativo del generatore di processi.
Directory()	Restituisce la directory di lavoro del generatore di processi.
Directory(File)	Imposta la directory di lavoro del generatore di processi.
Dispose()	Questa classe viene usata per creare processi del sistema operativo. (Ereditato da Object)
Dispose(Boolean)	Questa classe viene usata per creare processi del sistema operativo. (Ereditato da Object)
Environment()	Restituisce una visualizzazione mappa stringa dell'ambiente del generatore di processi.
Equals(Object)	Indica se un altro oggetto è "uguale a" questo. (Ereditato da Object)
GetHashCode()	Restituisce un valore del codice hash per l'oggetto. (Ereditato da Object)
InheritIO()	Imposta l'origine e la destinazione per l'I/O standard di subprocesso come quelli del processo Java corrente.
JavaFinalize()	Chiamato dal Garbage Collector in un oggetto quando Garbage Collection determina che non sono presenti più riferimenti all'oggetto. (Ereditato da Object)
Notify()	Riattiva un singolo thread in attesa del monitoraggio dell'oggetto. (Ereditato da Object)
NotifyAll()	Riattiva tutti i thread in attesa del monitoraggio dell'oggetto. (Ereditato da Object)
RedirectError()	Restituisce la destinazione di errore standard del generatore di processi.
RedirectError(File)	Imposta la destinazione di errore standard di questo generatore di processi su un file.
RedirectError(ProcessBuilder+Redirect)	Restituisce la destinazione di errore standard del generatore di processi.
RedirectErrorStream()	Indica se questo generatore di processi unisce l'errore standard e l'output standard.
RedirectErrorStream(Boolean)	Imposta la proprietà del redirectErrorStream generatore di processi.
RedirectInput()	Restituisce l'origine di input standard del generatore di processi.
RedirectInput(File)	Imposta l'origine di input standard di questo generatore di processi su un file.
RedirectInput(ProcessBuilder+Redirect)	Restituisce l'origine di input standard del generatore di processi.
RedirectOutput()	Restituisce la destinazione di output standard del generatore di processi.
RedirectOutput(File)	Imposta la destinazione di output standard del generatore di processi su un file.
RedirectOutput(ProcessBuilder+Redirect)	Restituisce la destinazione di output standard del generatore di processi.
SetHandle(IntPtr, JniHandleOwnership)	Imposta la proprietà Handle. (Ereditato da Object)
Start()	Avvia un nuovo processo usando gli attributi di questo generatore di processi.
ToArray<T>()	Questa classe viene usata per creare processi del sistema operativo. (Ereditato da Object)
ToString()	Restituisce una rappresentazione in formato stringa dell'oggetto. (Ereditato da Object)
UnregisterFromRuntime()	Questa classe viene usata per creare processi del sistema operativo. (Ereditato da Object)
Wait()	Causa l'attesa del thread corrente fino a quando non viene svegliata, in genere eseguendo>una notifica</em o <em interrotto</>em>>.< (Ereditato da Object)
Wait(Int64)	Causa l'attesa del thread corrente fino a quando non viene svegliata, in genere <>eseguendo una notifica</em o <em interrotto/>>em>o fino a quando non è trascorsa< una determinata quantità di tempo reale. (Ereditato da Object)
Wait(Int64, Int32)	Causa l'attesa del thread corrente fino a quando non viene svegliata, in genere <>eseguendo una notifica</em o <em interrotto/>>em>o fino a quando non è trascorsa< una determinata quantità di tempo reale. (Ereditato da Object)

Implementazioni dell'interfaccia esplicita

IJavaPeerable.Disposed()	Questa classe viene usata per creare processi del sistema operativo. (Ereditato da Object)
IJavaPeerable.DisposeUnlessReferenced()	Questa classe viene usata per creare processi del sistema operativo. (Ereditato da Object)
IJavaPeerable.Finalized()	Questa classe viene usata per creare processi del sistema operativo. (Ereditato da Object)
IJavaPeerable.JniManagedPeerState	Questa classe viene usata per creare processi del sistema operativo. (Ereditato da Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Questa classe viene usata per creare processi del sistema operativo. (Ereditato da Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Questa classe viene usata per creare processi del sistema operativo. (Ereditato da Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Questa classe viene usata per creare processi del sistema operativo. (Ereditato da Object)

Metodi di estensione

JavaCast<TResult>(IJavaObject)	Esegue una conversione dei tipi controllati dal runtime Android.
JavaCast<TResult>(IJavaObject)	Questa classe viene usata per creare processi del sistema operativo.
GetJniTypeName(IJavaPeerable)	Questa classe viene usata per creare processi del sistema operativo.