Process Osztály

Definíció

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

public ref class Process : IDisposable

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

public class Process : System.ComponentModel.Component, IDisposable

public class Process : IDisposable

public class Process : System.ComponentModel.Component

type Process = class
    inherit Component
    interface IDisposable

type Process = class
    interface IDisposable

type Process = class
    inherit Component

Public Class Process
Inherits Component
Implements IDisposable

Public Class Process
Implements IDisposable

Public Class Process
Inherits Component

Öröklődés

Object

MarshalByRefObject

Component

Process

Öröklődés

Object

Process

Megvalósítás

IDisposable

Példák

Az alábbi példa az Process osztály egy példányát használja a folyamat elindításához.

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

Az alábbi példa magát az Process osztályt és egy statikus Start metódust használ egy folyamat elindításához.

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

Az alábbi F# példa egy runProc folyamatot elindító függvényt határoz meg, rögzíti az összes kimeneti és hibainformációt, és rögzíti a folyamat által futtatott ezredmásodpercek számát. A runProc függvénynek három paramétere van: az elindítandó alkalmazás neve, az alkalmazásnak szolgáltatandó argumentumok és a kezdőkönyvtár.

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

A runProc függvény kódját ImaginaryDevelopment írta, és a Microsoft nyilvános licenc alatt érhető el.

Megjegyzések

Az Process összetevők hozzáférést biztosítanak egy számítógépen futó folyamathoz. A folyamat a legegyszerűbben egy futó alkalmazás. A szál az az alapegység, amelyhez az operációs rendszer processzoridőt rendel. A szálak a folyamat kódjának bármely részét végrehajthatják, beleértve a másik szál által jelenleg végrehajtott részeket is.

Az Process összetevő hasznos eszköz az alkalmazások indításához, leállításához, szabályozásához és monitorozásához. Használhatja az Process összetevőt, lekérjük a futó folyamatok listáját, vagy elindíthat egy új folyamatot. A Process rendszerfolyamatok eléréséhez egy összetevőt használunk. Egy Process összetevő inicializálása után a futó folyamat információinak lekérésére használható. Ezek az információk tartalmazzák a szálak készletét, a betöltött modulokat (.dll és .exe fájlokat), valamint a teljesítményre vonatkozó információkat, például a folyamat által használt memória mennyiségét.

Ez a típus implementálja a IDisposable felületet. Ha befejezte a típus használatát, közvetlenül vagy közvetve kell megsemmisítenie. A típus közvetlen ártalmatlanításához hívja meg a Dispose metódust egy try/finally blokkban. Ha közvetve szeretné megsemmisíteni, használjon olyan nyelvi szerkezetet, mint a using (C#-ban) vagy Using (a Visual Basicben). További információt a IDisposable felület dokumentációjának "Az IDisposable-t megvalósító objektum használata" című szakaszában talál.

A folyamatösszetevő egyszerre szerez be információkat egy tulajdonságcsoportról. Miután az Process összetevő információt kapott egy csoport egyik tagjáról, gyorsítótárazza a csoport többi tulajdonságának értékeit, és nem szerez be új információkat a csoport többi tagjáról, amíg meg nem hívja a metódust Refresh . Ezért a tulajdonságértékek nem garantáltan újabbak a metódus legutóbbi hívásánál Refresh . A csoportlebontások operációs rendszertől függenek.

Ha a rendszerben idézőjelek használatával deklarált egy elérési útváltozót, akkor az adott helyen található folyamatok indításakor teljes mértékben meg kell jelölnie ezt az elérési utat. Ellenkező esetben a rendszer nem találja az elérési utat. Ha például c:\mypath nem szerepel az elérési úton, és idézőjelek használatával adja hozzá: path = %path%;"c:\mypath"az indításkor minden folyamatot teljes mértékben minősíteni c:\mypath kell.

A rendszerfolyamatokat a rendszer egyedileg azonosítja a folyamatazonosítója alapján. Sok Windows erőforráshoz hasonlóan a leírója is azonosít egy folyamatot, amely nem feltétlenül egyedi a számítógépen. A leíró az erőforrás azonosítójának általános kifejezése. Az operációs rendszer megőrzi a folyamatleírót, amely az Handle összetevő tulajdonságán Process keresztül érhető el, még akkor is, ha a folyamat kilépett. Így lekérheti a folyamat adminisztratív adatait, például a ExitCode (általában nullát a sikerhez, vagy egy nem nulla hibakódot) és a ExitTime. A fogópontok rendkívül értékes erőforrást jelentenek, ezért a kiszivárogtató fogópontok sokkal vibrálóbbak, mint a memória kiszivárogtatása.

MacOS rendszeren a következő tulajdonságok 0 értéket adnak vissza:

• PeakVirtualMemorySize64
• PrivateMemorySize64
• PeakWorkingSet64

.NET alapjegyzetek

A .NET-keretrendszerben a Process osztály alapértelmezés szerint Console kódolásokat használ, amelyek általában kódlapkódolások a bemeneti, kimeneti és hibastreamekhez. Például olyan rendszereken, amelyek kultúrája angol (Egyesült Államok), a 437. kód a Console osztály alapértelmezett kódolása. A .NET Core azonban csak korlátozott részhalmazt tesz elérhetővé ezeknek a kódolásoknak. Ebben az esetben az alapértelmezett kódolást használja Encoding.UTF8 .

Ha egy Process objektum adott kódlapkódolástól függ, akkor is elérhetővé teheti őket az alábbi módon, mielőtt bármilyen Process metódust meghív:

1. Kérje le az EncodingProvider objektumot a CodePagesEncodingProvider.Instance tulajdonságból.

2. Adja át az EncodingProvider objektumot a Encoding.RegisterProvider metódusnak, hogy elérhetővé tegye a kódolásszolgáltató által támogatott további kódolásokat.

Az Process osztály ezután automatikusan az alapértelmezett rendszerkódolást használja az UTF8 helyett, feltéve, hogy regisztrálta a kódolási szolgáltatót, mielőtt bármilyen metódust Process meghívna.

Lásd még

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