Process Klass

Definition

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

public class Process : System.ComponentModel.Component

type Process = class
    inherit Component

Public Class Process
Inherits Component

Arv

Object

MarshalByRefObject

Component

Process

Exempel

I följande exempel används en instans av Process klassen för att starta en process.

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

I följande exempel används Process själva klassen och en statisk Start metod för att starta en process.

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

I följande F#-exempel definieras en runProc funktion som startar en process, samlar in all utdata och felinformation och registrerar antalet millisekunder som processen har kört. Funktionen runProc har tre parametrar: namnet på programmet som ska startas, argumenten som ska skickas till programmet och startkatalogen.

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

Koden för funktionen runProc skrevs av ImaginaryDevelopment och är tillgänglig under den offentliga licensen Microsoft.

Kommentarer

En Process komponent ger åtkomst till en process som körs på en dator. En process, i enklaste termer, är en app som körs. En tråd är den grundläggande enhet som operativsystemet allokerar processortid till. En tråd kan köra valfri del av processens kod, inklusive delar som för närvarande körs av en annan tråd.

Komponenten Process är ett användbart verktyg för att starta, stoppa, kontrollera och övervaka appar. Du kan använda komponenten Process för att hämta en lista över de processer som körs, eller så kan du starta en ny process. En Process komponent används för att komma åt systemprocesser. När en Process komponent har initierats kan den användas för att hämta information om körningsprocessen. Sådan information omfattar uppsättningen trådar, de inlästa modulerna (.dll och .exe filer) och prestandainformation som mängden minne som processen använder.

Den här typen implementerar IDisposable gränssnittet. När du har använt typen bör du kassera den på ett direkt eller indirekt sätt. Om du vill ta bort typen direkt anropar du dess Dispose metod i ett try/finally block. Om du vill ta bort det indirekt använder du en språkkonstruktion som using (i C#) eller Using (i Visual Basic). Mer information finns i avsnittet "Använda ett objekt som implementerar IDisposable" i gränssnittsdokumentationen IDisposable .

Processkomponenten hämtar information om en grupp med egenskaper samtidigt. När komponenten Process har fått information om en medlem i en grupp cachelagrade den värdena för de andra egenskaperna i gruppen och får inte ny information om de andra medlemmarna i gruppen förrän du anropar Refresh metoden. Därför är ett egenskapsvärde inte garanterat något nyare än det senaste anropet Refresh till metoden. Gruppuppdelningarna är beroende av operativsystem.

Om du har en sökvägsvariabel deklarerad i systemet med citattecken måste du fullständigt kvalificera den sökvägen när du startar en process som finns på den platsen. Annars hittar systemet inte sökvägen. Om det till exempel c:\mypath inte finns i sökvägen och du lägger till den med citattecken: path = %path%;"c:\mypath"måste du helt kvalificera alla processer när c:\mypath du startar den.

En systemprocess identifieras unikt i systemet av dess processidentifierare. Liksom många Windows resurser identifieras även en process av dess handtag, som kanske inte är unik på datorn. Ett handtag är den allmänna termen för en identifierare för en resurs. Operativsystemet bevarar processhandtaget, som nås via komponentens HandleProcess egenskap, även när processen har avslutats. Därför kan du hämta processens administrativa information, till exempel ExitCode (vanligtvis antingen noll för framgång eller en icke-noll felkod) och ExitTime. Handtag är en mycket värdefull resurs, så läckande handtag är mer virulent än läckande minne.

I macOS returnerar följande egenskaper 0:

• PeakVirtualMemorySize64
• PrivateMemorySize64
• PeakWorkingSet64

.NET Core Notes

I .NET Framework använder klassen Process som standard Console kodningar, som vanligtvis är kodningar för kodningar för indata, utdata och fel. Kodsida 437 är till exempel standardkodning för klassen Console på system vars kultur är engelska (United States). .NET Core kan dock endast göra en begränsad delmängd av dessa kodningar tillgängliga. I så fall används Encoding.UTF8 den som standardkodning.

Om ett Process objekt är beroende av specifika kodningskoder för kodning av kodningar kan du fortfarande göra dem tillgängliga genom att göra följande innan du anropar några Process metoder:

1. Hämta objektet EncodingProvider från egenskapen CodePagesEncodingProvider.Instance .

2. EncodingProvider Skicka objektet till Encoding.RegisterProvider metoden för att göra de ytterligare kodningar som stöds av kodningsprovidern tillgängliga.

Klassen Process använder sedan automatiskt standardsystemkodningen i stället för UTF8, förutsatt att du har registrerat kodningsprovidern innan du anropar några Process metoder.

Se även

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