Process Sınıf

Tanım

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

Devralma

Object

MarshalByRefObject

Component

Process

Devralma

Object

Process

Uygulamalar

IDisposable

Örnekler

Aşağıdaki örnek, bir işlemi başlatmak için sınıfının bir örneğini Process kullanır.

#using <System.dll>
using namespace System;
using namespace System::Diagnostics;
using namespace System::ComponentModel;

int main()
{
    Process^ myProcess = gcnew Process;

    try
    {
        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 );
    }
}

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);
            }
        }
    }
}

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

Aşağıdaki örnek, bir işlemi başlatmak için sınıfın Process kendisini ve statik Start bir yöntemi kullanır.

#using <System.dll>

using namespace System;
using namespace System::Diagnostics;
using namespace System::ComponentModel;

// 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()
{
    // 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");
}

// Uses the ProcessStartInfo class to start new processes,
// both in a minimized mode.
void OpenWithStartInfo()
{
    ProcessStartInfo^ startInfo = gcnew ProcessStartInfo("IExplore.exe");
    startInfo->WindowStyle = ProcessWindowStyle::Minimized;
    Process::Start(startInfo);
    startInfo->Arguments = "www.northwindtraders.com";
    Process::Start(startInfo);
}

int main()
{
    // Get the path that stores favorite links.
    String^ myFavoritesPath = Environment::GetFolderPath(Environment::SpecialFolder::Favorites);
    OpenApplication(myFavoritesPath);
    OpenWithArguments();
    OpenWithStartInfo();
}

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();
        }
    }
}

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

Aşağıdaki F# örneği bir işlemi başlatan, tüm çıkış ve hata bilgilerini yakalayan ve işlemin çalıştırdığı milisaniye sayısını kaydeden bir işlevi tanımlar runProc . runProc işlevi üç parametreye sahiptir: başlatacak uygulamanın adı, uygulamaya sağlamak için bağımsız değişkenler ve başlangıç dizini.

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

İşlevin runProc kodu ImaginaryDevelopment tarafından yazılmıştır ve Microsoft Genel Lisansı altında kullanılabilir.

Açıklamalar

Bileşen Process , bilgisayarda çalışan bir işleme erişim sağlar. En basit ifadeyle işlem, çalışan bir uygulamadır. İş parçacığı, işletim sisteminin işlemci süresini ayırdığı temel birimdir. İş parçacığı, şu anda başka bir iş parçacığı tarafından yürütülen parçalar da dahil olmak üzere işlem kodunun herhangi bir bölümünü yürütebilir.

Bileşen Process uygulamaları başlatmak, durdurmak, denetlemek ve izlemek için kullanışlı bir araçtır. Çalışan işlemlerin Process listesini almak için bileşenini kullanabilir veya yeni bir işlem başlatabilirsiniz. Sistem Process işlemlerine erişmek için bir bileşen kullanılır. Bir Process bileşen başlatıldıktan sonra, çalışan işlem hakkında bilgi almak için kullanılabilir. Bu tür bilgiler iş parçacıkları kümesini, yüklenen modülleri (.dll ve .exe dosyaları) ve işlemin kullandığı bellek miktarı gibi performans bilgilerini içerir.

Bu tür arabirimini IDisposable uygular. Türünü kullanmayı bitirdiğinizde, doğrudan veya dolaylı olarak atmalısınız. Türü doğrudan atmak için yöntemini bir try/finally blok içinde çağırın.Dispose Bunu dolaylı olarak atmak için (C#'de) veya Using (Visual Basic'te) gibi using bir dil yapısı kullanın. Daha fazla bilgi için arabirim belgelerindeki "IDisposable Uygulayan Bir Nesne Kullanma" bölümüne IDisposable bakın.

İşlem bileşeni, bir özellik grubu hakkında tüm bilgileri bir kerede alır. Process Bileşen herhangi bir grubun bir üyesi hakkında bilgi edindikten sonra, bu gruptaki diğer özelliklerin değerlerini önbelleğe alır ve siz yöntemini çağırana Refresh kadar grubun diğer üyeleri hakkında yeni bilgi edinmez. Bu nedenle, bir özellik değerinin yöntemine yapılan son çağrıdan Refresh daha yeni olması garanti değildir. Grup dökümleri işletim sistemine bağımlıdır.

Sisteminizde tırnak işaretleri kullanılarak bildirilen bir yol değişkeniniz varsa, bu konumda bulunan herhangi bir işlemi başlatırken bu yolu tam olarak nitelemeniz gerekir. Aksi takdirde sistem yolu bulamaz. Örneğin, yolunuz içinde değilse c:\mypath ve tırnak işaretlerini path = %path%;"c:\mypath"kullanarak eklerseniz, başlarken içindeki tüm işlemleri tam olarak nitelemeniz c:\mypath gerekir.

Sistem işlemi, işlem tanımlayıcısı tarafından sistemde benzersiz olarak tanımlanır. Birçok Windows kaynağında olduğu gibi, bir işlem de tanıtıcısı tarafından tanımlanır ve bu işlem bilgisayarda benzersiz olmayabilir. Tanıtıcı, bir kaynağın tanımlayıcısının genel terimidir. İşletim sistemi, işlemden çıkıldığında bile bileşenin HandleProcess özelliği aracılığıyla erişilen işlem tutamacını kalıcı hale gelir. Bu nedenle, (genellikle başarı için sıfır veya sıfır olmayan bir hata kodu) ve ExitTimegibi ExitCode işlemin yönetim bilgilerini alabilirsiniz. Tanıtıcılar son derece değerli bir kaynaktır, bu nedenle tutamaçların sızması bellek sızıntısından daha verimlidir.

.NET Core Notları

.NET Framework'da sınıfı Process varsayılan olarak giriş, çıkış ve hata akışları için kod sayfası kodlamaları olan kodlamaları kullanırConsole. Örneğin, kültürü İngilizce (Birleşik Devletler) olan sistemlerde kod sayfası 437 sınıfı için Console varsayılan kodlamadır. Ancak.NET Core, bu kodlamaların yalnızca sınırlı bir alt kümesini kullanılabilir hale getirebilir. Bu durumda, varsayılan kodlama olarak kullanır Encoding.UTF8 .

Bir nesne belirli kod sayfası kodlamalarına bağımlıysa, herhangi bir ProcessProcess yöntemi çağırmadan önce aşağıdakileri yaparak bunları kullanılabilir hale getirebilirsiniz:

1. EncodingProvider özelliğinden CodePagesEncodingProvider.Instance nesnesini alın.

2. EncodingProvider Kodlama sağlayıcısı tarafından desteklenen ek kodlamaları kullanılabilir hale getirmek için nesnesini Encoding.RegisterProvider yöntemine geçirin.

Daha Process sonra sınıf, herhangi bir Process yöntemi çağırmadan önce kodlama sağlayıcısını kaydetmiş olmanız koşuluyla UTF8 yerine varsayılan sistem kodlamasını otomatik olarak kullanır.

Oluşturucular

Özellikler

Yöntemler

Ekinlikler

Şunlara uygulanır

Ayrıca bkz.

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