Process Klas

Definitie

public ref class Process : System::ComponentModel::Component

public class Process : System.ComponentModel.Component

type Process = class
    inherit Component

Public Class Process
Inherits Component

Overname

Object

MarshalByRefObject

Component

Process

Voorbeelden

In het volgende voorbeeld wordt een exemplaar van de Process klasse gebruikt om een proces te starten.

using System;
using System.Diagnostics;
using System.ComponentModel;

namespace MyProcessSample
{
    class MyProcess
    {
        public static void Main()
        {
            try
            {
                using (Process myProcess = new Process())
                {
                    myProcess.StartInfo.UseShellExecute = false;
                    // You can start any process, HelloWorld is a do-nothing example.
                    myProcess.StartInfo.FileName = "C:\\HelloWorld.exe";
                    myProcess.StartInfo.CreateNoWindow = true;
                    myProcess.Start();
                    // This code assumes the process you are starting will terminate itself.
                    // Given that it is started without a window so you cannot terminate it
                    // on the desktop, it must terminate itself or you can do it programmatically
                    // from this application using the Kill method.
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

open System.Diagnostics

try
    use myProcess = new Process()
    myProcess.StartInfo.UseShellExecute <- false
    // You can start any process, HelloWorld is a do-nothing example.
    myProcess.StartInfo.FileName <- @"C:\HelloWorld.exe"
    myProcess.StartInfo.CreateNoWindow <- true
    myProcess.Start() |> ignore
// This code assumes the process you are starting will terminate itself.
// Given that it is started without a window so you cannot terminate it
// on the desktop, it must terminate itself or you can do it programmatically
// from this application using the Kill method.
with e ->
    printfn $"{e.Message}"

Imports System.Diagnostics
Imports System.ComponentModel

Namespace MyProcessSample
    Class MyProcess
        Public Shared Sub Main()
            Try
                Using myProcess As New Process()

                    myProcess.StartInfo.UseShellExecute = False
                    ' You can start any process, HelloWorld is a do-nothing example.
                    myProcess.StartInfo.FileName = "C:\\HelloWorld.exe"
                    myProcess.StartInfo.CreateNoWindow = True
                    myProcess.Start()
                    ' This code assumes the process you are starting will terminate itself. 
                    ' Given that it is started without a window so you cannot terminate it 
                    ' on the desktop, it must terminate itself or you can do it programmatically
                    ' from this application using the Kill method.
                End Using
            Catch e As Exception
                Console.WriteLine((e.Message))
            End Try
        End Sub
    End Class
End Namespace

In het volgende voorbeeld wordt de Process klasse zelf en een statische Start methode gebruikt om een proces te starten.

using System;
using System.Diagnostics;
using System.ComponentModel;

namespace MyProcessSample
{
    class MyProcess
    {
        // Opens the Internet Explorer application.
        void OpenApplication(string myFavoritesPath)
        {
            // Start Internet Explorer. Defaults to the home page.
            Process.Start("IExplore.exe");

            // Display the contents of the favorites folder in the browser.
            Process.Start(myFavoritesPath);
        }

        // Opens urls and .html documents using Internet Explorer.
        void OpenWithArguments()
        {
            // url's are not considered documents. They can only be opened
            // by passing them as arguments.
            Process.Start("IExplore.exe", "www.northwindtraders.com");

            // Start a Web page using a browser associated with .html and .asp files.
            Process.Start("IExplore.exe", "C:\\myPath\\myFile.htm");
            Process.Start("IExplore.exe", "C:\\myPath\\myFile.asp");
        }

        // Uses the ProcessStartInfo class to start new processes,
        // both in a minimized mode.
        void OpenWithStartInfo()
        {
            ProcessStartInfo startInfo = new ProcessStartInfo("IExplore.exe");
            startInfo.WindowStyle = ProcessWindowStyle.Minimized;

            Process.Start(startInfo);

            startInfo.Arguments = "www.northwindtraders.com";

            Process.Start(startInfo);
        }

        static void Main()
        {
            // Get the path that stores favorite links.
            string myFavoritesPath =
                Environment.GetFolderPath(Environment.SpecialFolder.Favorites);

            MyProcess myProcess = new MyProcess();

            myProcess.OpenApplication(myFavoritesPath);
            myProcess.OpenWithArguments();
            myProcess.OpenWithStartInfo();
        }
    }
}

module processstartstatic

open System
open System.Diagnostics

// Opens the Internet Explorer application.
let openApplication (myFavoritesPath: string) =
    // Start Internet Explorer. Defaults to the home page.
    Process.Start "IExplore.exe" |> ignore

    // Display the contents of the favorites folder in the browser.
    Process.Start myFavoritesPath |> ignore

// Opens urls and .html documents using Internet Explorer.
let openWithArguments () =
    // url's are not considered documents. They can only be opened
    // by passing them as arguments.
    Process.Start("IExplore.exe", "www.northwindtraders.com") |> ignore

    // Start a Web page using a browser associated with .html and .asp files.
    Process.Start("IExplore.exe", @"C:\myPath\myFile.htm") |> ignore
    Process.Start("IExplore.exe", @"C:\myPath\myFile.asp") |> ignore

// Uses the ProcessStartInfo class to start new processes,
// both in a minimized mode.
let openWithStartInfo () =
    let startInfo = ProcessStartInfo "IExplore.exe"
    startInfo.WindowStyle <- ProcessWindowStyle.Minimized

    Process.Start startInfo |> ignore

    startInfo.Arguments <- "www.northwindtraders.com"

    Process.Start startInfo |> ignore

// Get the path that stores favorite links.
let myFavoritesPath = Environment.GetFolderPath Environment.SpecialFolder.Favorites

openApplication myFavoritesPath
openWithArguments ()
openWithStartInfo ()

Imports System.Diagnostics
Imports System.ComponentModel

Namespace MyProcessSample
    Class MyProcess
        ' Opens the Internet Explorer application.
        Public Sub OpenApplication(myFavoritesPath As String)
            ' Start Internet Explorer. Defaults to the home page.
            Process.Start("IExplore.exe")

            ' Display the contents of the favorites folder in the browser.
            Process.Start(myFavoritesPath)
        End Sub

        ' Opens URLs and .html documents using Internet Explorer.
        Sub OpenWithArguments()
            ' URLs are not considered documents. They can only be opened
            ' by passing them as arguments.
            Process.Start("IExplore.exe", "www.northwindtraders.com")

            ' Start a Web page using a browser associated with .html and .asp files.
            Process.Start("IExplore.exe", "C:\myPath\myFile.htm")
            Process.Start("IExplore.exe", "C:\myPath\myFile.asp")
        End Sub

        ' Uses the ProcessStartInfo class to start new processes,
        ' both in a minimized mode.
        Sub OpenWithStartInfo()
            Dim startInfo As New ProcessStartInfo("IExplore.exe")
            startInfo.WindowStyle = ProcessWindowStyle.Minimized

            Process.Start(startInfo)

            startInfo.Arguments = "www.northwindtraders.com"

            Process.Start(startInfo)
        End Sub

        Shared Sub Main()
            ' Get the path that stores favorite links.
            Dim myFavoritesPath As String = Environment.GetFolderPath(Environment.SpecialFolder.Favorites)

            Dim myProcess As New MyProcess()

            myProcess.OpenApplication(myFavoritesPath)
            myProcess.OpenWithArguments()
            myProcess.OpenWithStartInfo()
        End Sub
    End Class
End Namespace 'MyProcessSample

In het volgende F#-voorbeeld wordt een runProc functie gedefinieerd waarmee een proces wordt gestart, alle uitvoer- en foutgegevens worden vastgelegd en wordt het aantal milliseconden vastgelegd dat het proces heeft uitgevoerd. De runProc functie heeft drie parameters: de naam van de toepassing die moet worden gestart, de argumenten die moeten worden opgegeven voor de toepassing en de beginmap.

open System
open System.Diagnostics

let runProc filename args startDir : seq<string> * seq<string> = 
    let timer = Stopwatch.StartNew()
    let procStartInfo = 
        ProcessStartInfo(
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            UseShellExecute = false,
            FileName = filename,
            Arguments = args
        )
    match startDir with | Some d -> procStartInfo.WorkingDirectory <- d | _ -> ()

    let outputs = System.Collections.Generic.List<string>()
    let errors = System.Collections.Generic.List<string>()
    let outputHandler f (_sender:obj) (args:DataReceivedEventArgs) = f args.Data
    use p = new Process(StartInfo = procStartInfo)
    p.OutputDataReceived.AddHandler(DataReceivedEventHandler (outputHandler outputs.Add))
    p.ErrorDataReceived.AddHandler(DataReceivedEventHandler (outputHandler errors.Add))
    let started = 
        try
            p.Start()
        with | ex ->
            ex.Data.Add("filename", filename)
            reraise()
    if not started then
        failwithf "Failed to start process %s" filename
    printfn "Started %s with pid %i" p.ProcessName p.Id
    p.BeginOutputReadLine()
    p.BeginErrorReadLine()
    p.WaitForExit()
    timer.Stop()
    printfn "Finished %s after %A milliseconds" filename timer.ElapsedMilliseconds
    let cleanOut l = l |> Seq.filter (fun o -> String.IsNullOrEmpty o |> not)
    cleanOut outputs,cleanOut errors

De code voor de functie runProc is geschreven door ImaginaryDevelopment en is beschikbaar onder de Microsoft Openbare licentie.

Opmerkingen

Een Process onderdeel biedt toegang tot een proces dat wordt uitgevoerd op een computer. Een proces, in de eenvoudigste termen, is een actieve app. Een thread is de basiseenheid waaraan het besturingssysteem processortijd toewijst. Een thread kan elk deel van de code van het proces uitvoeren, inclusief onderdelen die momenteel door een andere thread worden uitgevoerd.

Het Process onderdeel is een handig hulpmiddel voor het starten, stoppen, beheren en bewaken van apps. U kunt het Process onderdeel gebruiken om een lijst op te halen met de processen die worden uitgevoerd, of u kunt een nieuw proces starten. Een Process onderdeel wordt gebruikt voor toegang tot systeemprocessen. Nadat een Process onderdeel is geïnitialiseerd, kan het worden gebruikt om informatie te verkrijgen over het actieve proces. Dergelijke informatie omvat de set threads, de geladen modules (.dll- en .exe-bestanden) en prestatiegegevens zoals de hoeveelheid geheugen die het proces gebruikt.

Met dit type wordt de IDisposable interface geïmplementeerd. Wanneer u klaar bent met het gebruik van het type, moet u het direct of indirect verwijderen. Als u het type rechtstreeks wilt verwijderen, roept u de Dispose methode aan in een try/finally blok. Als u deze indirect wilt verwijderen, gebruikt u een taalconstructie zoals using (in C#) of Using (in Visual Basic). Zie de sectie 'Using an Object that Implements IDisposable' (Een object gebruiken dat IDisposable implementeert) in de IDisposable interfacedocumentatie voor meer informatie.

Het procesonderdeel verkrijgt informatie over een groep eigenschappen allemaal tegelijk. Nadat het Process onderdeel informatie over één lid van een groep heeft verkregen, worden de waarden voor de andere eigenschappen in die groep in de cache opgeslagen en worden er pas nieuwe gegevens over de andere leden van de groep opgehaald nadat u de Refresh methode hebt aangeroepen. Daarom is een eigenschapswaarde niet gegarandeerd nieuwer dan de laatste aanroep van de Refresh methode. De groepsanalyses zijn afhankelijk van het besturingssysteem.

Als u een padvariabele hebt gedeclareerd in uw systeem met aanhalingstekens, moet u dat pad volledig kwalificeren bij het starten van een proces dat op die locatie is gevonden. Anders vindt het systeem het pad niet. Als het pad zich bijvoorbeeld c:\mypath niet in uw pad bevindt en u het toevoegt met aanhalingstekens: path = %path%;"c:\mypath", moet u een proces c:\mypath volledig kwalificeren bij het starten ervan.

Een systeemproces wordt uniek geïdentificeerd op het systeem door de proces-id. Net als bij veel Windows resources wordt een proces ook geïdentificeerd door de ingang, die mogelijk niet uniek is op de computer. Een handle is de algemene term voor een id van een resource. Het besturingssysteem blijft de procesgreep behouden, die wordt geopend via de Handle eigenschap van het Process onderdeel, zelfs wanneer het proces is afgesloten. Zo kunt u de administratieve gegevens van het proces ophalen, zoals de ExitCode (meestal nul voor succes of een niet-nulfoutcode) en de ExitTime. Handles zijn een zeer waardevolle resource, dus lekkende ingangen zijn meer virulent dan het lekken van geheugen.

In macOS retourneren de volgende eigenschappen 0:

• PeakVirtualMemorySize64
• PrivateMemorySize64
• PeakWorkingSet64

Basisnotities .NET

In .NET Framework gebruikt de klasse Process standaard Console coderingen, die doorgaans codepaginacoderingen zijn, voor de invoer-, uitvoer- en foutstromen. Code bijvoorbeeld, op systemen waarvan de cultuur Engels (Verenigde Staten) is, is codepagina 437 de standaardcodering voor de klasse Console. .NET Core kan echter slechts een beperkte subset van deze coderingen beschikbaar maken. Als dit het geval is, wordt deze gebruikt Encoding.UTF8 als de standaardcodering.

Als een Process object afhankelijk is van specifieke codepaginacoderingen, kunt u deze nog steeds beschikbaar maken door het volgende te doen voordat u methoden Process aanroept:

1. Haal het EncodingProvider object op uit de CodePagesEncodingProvider.Instance eigenschap.

2. Geef het EncodingProvider object door aan de Encoding.RegisterProvider methode om de aanvullende coderingen beschikbaar te maken die worden ondersteund door de coderingsprovider.

De Process klasse gebruikt vervolgens automatisch de standaardsysteemcodering in plaats van UTF8, mits u de coderingsprovider hebt geregistreerd voordat u methoden aanroept Process .

Zie ook

• Start()
• ProcessStartInfo
• CloseMainWindow()
• Kill()
• ProcessThread