Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Process classe

 

Date de publication : novembre 2016

Fournit l'accès à des processus locaux ainsi que distants, et vous permet de démarrer et d'arrêter des processus système locaux.

Pour parcourir le code source de .NET Framework pour ce type, consultez la Source de référence.

Espace de noms:   System.Diagnostics
Assembly:  System (dans System.dll)


[PermissionSetAttribute(SecurityAction.LinkDemand, Name = "FullTrust")]
[HostProtectionAttribute(SecurityAction.LinkDemand, SharedState = true, 
	Synchronization = true, ExternalProcessMgmt = true, SelfAffectingProcessMgmt = true)]
[PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
public class Process : Component

NomDescription
System_CAPS_pubmethodProcess()

Initialise une nouvelle instance de la classe Process.

NomDescription
System_CAPS_pubpropertyBasePriority

Obtient la priorité de base du processus associé.

System_CAPS_protpropertyCanRaiseEvents

Obtient une valeur indiquant si le composant peut déclencher un événement.(Hérité de Component.)

System_CAPS_pubpropertyContainer

Obtient les IContainer qui contient la Component.(Hérité de Component.)

System_CAPS_protpropertyDesignMode

Obtient une valeur qui indique si la Component est actuellement en mode design.(Hérité de Component.)

System_CAPS_pubpropertyEnableRaisingEvents

Obtient ou définit une valeur indiquant si l'événement Exited est déclenché quand le processus ne s'exécute plus.

System_CAPS_protpropertyEvents

Obtient la liste des gestionnaires d’événements associés à cette Component.(Hérité de Component.)

System_CAPS_pubpropertyExitCode

Obtient la valeur spécifiée par le processus associé au moment où il s'est terminé.

System_CAPS_pubpropertyExitTime

Obtient l'heure à laquelle le processus associé s'est terminé.

System_CAPS_pubpropertyHandle

Obtient le handle natif du processus associé.

System_CAPS_pubpropertyHandleCount

Obtient le nombre de handles ouverts par le processus.

System_CAPS_pubpropertyHasExited

Obtient une valeur indiquant si le processus associé s'est terminé.

System_CAPS_pubpropertyId

Obtient l'identificateur unique du processus associé.

System_CAPS_pubpropertyMachineName

Obtient le nom de l'ordinateur sur lequel s'exécute le processus associé.

System_CAPS_pubpropertyMainModule

Obtient le module principal pour le processus associé.

System_CAPS_pubpropertyMainWindowHandle

Obtient le handle de la fenêtre principale du processus associé.

System_CAPS_pubpropertyMainWindowTitle

Obtient la légende de la fenêtre principale du processus.

System_CAPS_pubpropertyMaxWorkingSet

Obtient ou définit la taille maximale autorisée du jeu de travail, en octets, pour le processus associé.

System_CAPS_pubpropertyMinWorkingSet

Obtient ou définit la taille minimale autorisée du jeu de travail, en octets, pour le processus associé.

System_CAPS_pubpropertyModules

Obtient les modules qui ont été chargés par le processus associé.

System_CAPS_pubpropertyNonpagedSystemMemorySize

Obsolète. Obtient la quantité de mémoire système non paginée, en octets, allouée pour le processus associé.

System_CAPS_pubpropertyNonpagedSystemMemorySize64

Obtient la quantité de mémoire système non paginée, en octets, allouée pour le processus associé.

System_CAPS_pubpropertyPagedMemorySize

Obsolète. Obtient la quantité de mémoire paginée, en octets, allouée pour le processus associé.

System_CAPS_pubpropertyPagedMemorySize64

Obtient la quantité de mémoire paginée, en octets, allouée au processus associé.

System_CAPS_pubpropertyPagedSystemMemorySize

Obsolète. Obtient la quantité de mémoire système paginable, en octets, allouée pour le processus associé.

System_CAPS_pubpropertyPagedSystemMemorySize64

Obtient la quantité de mémoire système paginable, en octets, allouée pour le processus associé.

System_CAPS_pubpropertyPeakPagedMemorySize

Obsolète. Obtient la quantité maximale de mémoire dans le fichier d’échange de la mémoire virtuelle, en octets, utilisé par le processus associé.

System_CAPS_pubpropertyPeakPagedMemorySize64

Obtient la quantité maximale de mémoire dans le fichier d’échange de la mémoire virtuelle, en octets, utilisé par le processus associé.

System_CAPS_pubpropertyPeakVirtualMemorySize

Obsolète. Obtient la quantité maximale de la mémoire virtuelle, en octets, utilisée par le processus associé.

System_CAPS_pubpropertyPeakVirtualMemorySize64

Obtient la quantité maximale de la mémoire virtuelle, en octets, utilisée par le processus associé.

System_CAPS_pubpropertyPeakWorkingSet

Obsolète. Obtient la taille maximale du jeu de travail du processus associé, en octets.

System_CAPS_pubpropertyPeakWorkingSet64

Obtient la quantité maximale de mémoire physique, en octets, utilisée par le processus associé.

System_CAPS_pubpropertyPriorityBoostEnabled

Obtient ou définit une valeur indiquant si la priorité du processus associée doit être temporairement renforcée par le système d'exploitation quand la fenêtre principale a le focus.

System_CAPS_pubpropertyPriorityClass

Obtient ou définit la catégorie de priorité générale pour le processus associé.

System_CAPS_pubpropertyPrivateMemorySize

Obsolète. Obtient la quantité de mémoire privée, en octets, allouée pour le processus associé.

System_CAPS_pubpropertyPrivateMemorySize64

Obtient la quantité de mémoire privée, en octets, allouée pour le processus associé.

System_CAPS_pubpropertyPrivilegedProcessorTime

Obtient le temps processeur privilégié pour ce processus.

System_CAPS_pubpropertyProcessName

Obtient le nom du processus.

System_CAPS_pubpropertyProcessorAffinity

Obtient ou définit les processeurs sur lesquels l'exécution des threads de ce processus peut être planifiée.

System_CAPS_pubpropertyResponding

Obtient une valeur indiquant si l'interface utilisateur du processus répond.

System_CAPS_pubpropertySafeHandle

Obtient le handle natif de ce processus.

System_CAPS_pubpropertySessionId

Obtient l'identificateur de session Terminal Server du processus associé.

System_CAPS_pubpropertySite

Obtient ou définit le ISite de la Component.(Hérité de Component.)

System_CAPS_pubpropertyStandardError

Obtient un flux utilisé pour lire la sortie d'erreur de l'application.

System_CAPS_pubpropertyStandardInput

Obtient un flux utilisé pour écrire l'entrée de l'application.

System_CAPS_pubpropertyStandardOutput

Obtient un flux utilisé pour lire la sortie textuelle de l'application.

System_CAPS_pubpropertyStartInfo

Obtient ou définit les propriétés à passer à la méthode Start de Process.

System_CAPS_pubpropertyStartTime

Obtient l'heure à laquelle le processus associé a démarré.

System_CAPS_pubpropertySynchronizingObject

Obtient ou définit l’objet utilisé pour marshaler des appels du gestionnaire d’événements émis à la suite d’un événement de sortie de processus.

System_CAPS_pubpropertyThreads

Obtient le jeu des threads en cours d'exécution dans le processus associé.

System_CAPS_pubpropertyTotalProcessorTime

Obtient le temps processeur total pour ce processus.

System_CAPS_pubpropertyUserProcessorTime

Obtient le temps processeur utilisateur pour ce processus.

System_CAPS_pubpropertyVirtualMemorySize

Obsolète. Obtient la taille (en octets) de la mémoire virtuelle du processus.

System_CAPS_pubpropertyVirtualMemorySize64

Obtient la quantité de mémoire virtuelle, en octets, allouée au processus associé.

System_CAPS_pubpropertyWorkingSet

Obsolète. Obtient l’utilisation de mémoire physique du processus associé, en octets.

System_CAPS_pubpropertyWorkingSet64

Obtient la quantité de mémoire physique, en octets, allouée au processus associé.

NomDescription
System_CAPS_pubmethodBeginErrorReadLine()

Commence des opérations de lecture asynchrones sur le flux de données StandardError redirigé de l'application.

System_CAPS_pubmethodBeginOutputReadLine()

Commence des opérations de lecture asynchrones sur le flux de données StandardOutput redirigé de l'application.

System_CAPS_pubmethodCancelErrorRead()

Annule l'opération de lecture asynchrone sur le flux StandardError redirigé d'une application.

System_CAPS_pubmethodCancelOutputRead()

Annule l'opération de lecture asynchrone sur le flux StandardOutput redirigé d'une application.

System_CAPS_pubmethodClose()

Libère toutes les ressources associées à ce composant.

System_CAPS_pubmethodCloseMainWindow()

Ferme un processus possédant une interface utilisateur en envoyant un message de fermeture à sa fenêtre principale.

System_CAPS_pubmethodCreateObjRef(Type)

Crée un objet qui contient toutes les informations requises pour générer un proxy permettant de communiquer avec un objet distant.(Hérité de MarshalByRefObject.)

System_CAPS_pubmethodDispose()

Libère toutes les ressources utilisées par Component.(Hérité de Component.)

System_CAPS_protmethodDispose(Boolean)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Libère toutes les ressources utilisées par ce processus.(Remplace Component.Dispose(Boolean).)

System_CAPS_pubmethodSystem_CAPS_staticEnterDebugMode()

Met un composant Process en état d'interagir avec des processus du système d'exploitation qui s'exécutent en mode spécial en activant la propriété native SeDebugPrivilege sur le thread actuel.

System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_protmethodFinalize()

Libère les ressources non managées et exécute d'autres opérations de nettoyage avant la récupération du Component par le garbage collection.(Hérité de Component.)

System_CAPS_pubmethodSystem_CAPS_staticGetCurrentProcess()

Obtient un nouveau composant Process et l'associe au processus actuellement actif.

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodGetLifetimeService()

Récupère l’objet de service de durée de vie actuelle qui contrôle la stratégie de durée de vie de cette instance.(Hérité de MarshalByRefObject.)

System_CAPS_pubmethodSystem_CAPS_staticGetProcessById(Int32)

Retourne un nouveau composant Process, en fonction de l'identificateur d'un processus sur l'ordinateur local.

System_CAPS_pubmethodSystem_CAPS_staticGetProcessById(Int32, String)

Retourne un nouveau composant Process, en fonction d'un identificateur de processus et du nom d'un ordinateur du réseau.

System_CAPS_pubmethodSystem_CAPS_staticGetProcesses()

Crée un composant Process pour chaque ressource de processus sur l'ordinateur local.

System_CAPS_pubmethodSystem_CAPS_staticGetProcesses(String)

Crée un composant Process pour chaque ressource de processus sur l'ordinateur spécifié.

System_CAPS_pubmethodSystem_CAPS_staticGetProcessesByName(String)

Crée un tableau de nouveaux composants Process et les associe à toutes les ressources de processus de l'ordinateur local qui partagent le nom de processus spécifié.

System_CAPS_pubmethodSystem_CAPS_staticGetProcessesByName(String, String)

Crée un tableau de nouveaux composants Process et les associe à toutes les ressources de processus sur l'ordinateur distant qui partagent le nom de processus spécifié.

System_CAPS_protmethodGetService(Type)

Retourne un objet qui représente un service fourni par Component ou par son Container.(Hérité de Component.)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodInitializeLifetimeService()

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.(Hérité de MarshalByRefObject.)

System_CAPS_pubmethodKill()

Arrête immédiatement le processus associé.

System_CAPS_pubmethodSystem_CAPS_staticLeaveDebugMode()

Met un composant Process hors de l'état qui lui permet d'interagir avec des processus du système d'exploitation qui s'exécutent en mode spécial.

System_CAPS_protmethodMemberwiseClone()

Crée une copie superficielle du Object actuel.(Hérité de Object.)

System_CAPS_protmethodMemberwiseClone(Boolean)

Crée une copie superficielle d’actuel MarshalByRefObject objet.(Hérité de MarshalByRefObject.)

System_CAPS_protmethodOnExited()

Déclenche l'événement Exited.

System_CAPS_pubmethodRefresh()

Ignore toute information concernant le processus associé qui a été mis en cache dans le composant du processus.

System_CAPS_pubmethodStart()

Démarre (ou réutilise) la ressource de processus qui est spécifiée par la propriété StartInfo de ce composant Process et l'associe au composant.

System_CAPS_pubmethodSystem_CAPS_staticStart(ProcessStartInfo)

Démarre la ressource de processus qui est spécifiée par le paramètre contenant les informations de démarrage du processus (par exemple, le nom de fichier du processus à démarrer) et l'associe à un nouveau composant Process.

System_CAPS_pubmethodSystem_CAPS_staticStart(String)

Démarre une ressource de processus en spécifiant le nom d'un document ou d'un fichier d'application et l'associe à un nouveau composant Process.

System_CAPS_pubmethodSystem_CAPS_staticStart(String, String)

Démarre une ressource de processus en spécifiant le nom d'une application et un jeu d'arguments de ligne de commande et l'associe à la ressource avec un nouveau composant Process.

System_CAPS_pubmethodSystem_CAPS_staticStart(String, String, SecureString, String)

Démarre une ressource de processus en spécifiant le nom d'une application, un nom d'utilisateur, un mot de passe et un domaine et associe la ressource à un nouveau composant Process.

System_CAPS_pubmethodSystem_CAPS_staticStart(String, String, String, SecureString, String)

Démarre une ressource de processus en spécifiant le nom d'une application, un jeu d'arguments de ligne de commande, un nom d'utilisateur, un mot de passe et un domaine, et associe la ressource à un nouveau composant Process.

System_CAPS_pubmethodToString()

Met en forme le nom du processus en tant que chaîne, combinée au type de composant parent, le cas échéant.(Remplace Component.ToString().)

System_CAPS_pubmethodWaitForExit()

Indique au composant Process d'attendre indéfiniment que le processus associé s'arrête.

System_CAPS_pubmethodWaitForExit(Int32)

Indique au composant Process d'attendre le nombre de millisecondes spécifié que le processus associé s'arrête.

System_CAPS_pubmethodWaitForInputIdle()

Fait en sorte que le composant Process attende indéfiniment que le processus associé passe à un état inactif. Cette surcharge s'applique uniquement aux processus dotés d'une interface utilisateur et, donc, d'une boucle de message.

System_CAPS_pubmethodWaitForInputIdle(Int32)

Fait en sorte que le composant Process attende pendant le nombre spécifié de millisecondes que le processus associé passe à un état inactif. Cette surcharge s'applique uniquement aux processus dotés d'une interface utilisateur et, donc, d'une boucle de message.

NomDescription
System_CAPS_pubeventDisposed

Se produit lorsque le composant est supprimé par un appel à la Dispose (méthode).(Hérité de Component.)

System_CAPS_pubeventErrorDataReceived

Se produit quand une application écrit dans son flux StandardError redirigé.

System_CAPS_pubeventExited

Se produit quand un processus se termine.

System_CAPS_pubeventOutputDataReceived

Se produit quand une application écrit dans son flux StandardOutput redirigé.

System_CAPS_noteRemarque

To view the .NET Framework source code for this type, see the Reference Sourcehttp://referencesource.microsoft.com/#System/services/monitoring/system/diagnosticts/Process.cs#f8b2e604d6f1fe04. You can browse through the source code online, download the reference for offline viewing, and step through the sources (including patches and updates) during debugging; see instructionshttp://referencesource.microsoft.com/.

A T:System.Diagnostics.Process component provides access to a process that is running on a computer. A process, in the simplest terms, is a running app. A thread is the basic unit to which the operating system allocates processor time. A thread can execute any part of the code of the process, including parts currently being executed by another thread.

The T:System.Diagnostics.Process component is a useful tool for starting, stopping, controlling, and monitoring apps. You can use the T:System.Diagnostics.Process component, to obtain a list of the processes that are running, or you can start a new process. A T:System.Diagnostics.Process component is used to access system processes. After a T:System.Diagnostics.Process component has been initialized, it can be used to obtain information about the running process. Such information includes the set of threads, the loaded modules (.dll and .exe files), and performance information such as the amount of memory the process is using.

This type implements the T:System.IDisposable interface. When you have finished using the type, you should dispose of it either directly or indirectly. To dispose of the type directly, call its M:System.IDisposable.Dispose method in a try/catch block. To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). For more information, see the “Using an Object that Implements IDisposable” section in the T:System.IDisposable interface topic.

System_CAPS_noteRemarque

32-bit processes cannot access the modules of a 64-bit process. If you try to get information about a 64-bit process from a 32-bit process, you will get a T:System.ComponentModel.Win32Exception exception. A 64-bit process, on the other hand, can access the modules of a 32-bit process.

The process component obtains information about a group of properties all at once. After the T:System.Diagnostics.Process component has obtained information about one member of any group, it will cache the values for the other properties in that group and not obtain new information about the other members of the group until you call the M:System.Diagnostics.Process.Refresh method. Therefore, a property value is not guaranteed to be any newer than the last call to the M:System.Diagnostics.Process.Refresh method. The group breakdowns are operating-system dependent.

If you have a path variable declared in your system using quotes, you must fully qualify that path when starting any process found in that location. Otherwise, the system will not find the path. For example, if c:\mypath is not in your path, and you add it using quotation marks: path = %path%;"c:\mypath", you must fully qualify any process in c:\mypath when starting it.

A system process is uniquely identified on the system by its process identifier. Like many Windows resources, a process is also identified by its handle, which might not be unique on the computer. A handle is the generic term for an identifier of a resource. The operating system persists the process handle, which is accessed through the P:System.Diagnostics.Process.Handle property of the T:System.Diagnostics.Process component, even when the process has exited. Thus, you can get the process's administrative information, such as the P:System.Diagnostics.Process.ExitCode (usually either zero for success or a nonzero error code) and the P:System.Diagnostics.Process.ExitTime. Handles are an extremely valuable resource, so leaking handles is more virulent than leaking memory.

System_CAPS_noteRemarque

This class contains a link demand and an inheritance demand at the class level that applies to all members. A T:System.Security.SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. For details about security demands, see Link Demands.

In the .NET Framework on the desktop, the T:System.Diagnostics.Process class by default uses T:System.Console encodings, which are typically code page encodings, for the input, output, and error streams. For example code, on systems whose culture is English (United States), code page 437 is the default encoding for the T:System.Console class. However, net_core may make only a limited subset of these encodings available. If this is the case, it uses P:System.Text.Encoding.UTF8 as the default encoding.

If a T:System.Diagnostics.Process object depends on specific code page encodings, you can still make them available by doing the following before you call any T:System.Diagnostics.Process methods:

  1. Add a reference to the System.Text.Encoding.CodePages.dll assembly to your project.

  2. Retrieve the T:System.Text.EncodingProvider object from the P:System.Text.CodePagesEncodingProvider.Instance property.

  3. Pass the T:System.Text.EncodingProvider object to the M:System.Text.Encoding.RegisterProvider(System.Text.EncodingProvider) method to make the additional encodings supported by the encoding provider available.

The T:System.Diagnostics.Process class will then automatically use the default system encoding rather than UTF8, provided that you have registered the encoding provider before calling any T:System.Diagnostics.Process methods.

The following example uses an instance of the T:System.Diagnostics.Process class to start a process.

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

namespace MyProcessSample
{
    class MyProcess
    {
        public static void Main()
        {
            Process myProcess = new 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 is 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);
            }
        }
    }
}

The following example uses the T:System.Diagnostics.Process class itself and a static M:System.Diagnostics.Process.Start method to start a 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();
        }
    }
}

The following F# example defines a runProc function that starts a process, captures all output and error information, and records the number of milliseconds that the process has run. The runProc function has three parameters: the name of application to launch, the arguments to supply to the application, and the starting directory.

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

The code for the runProc function was written by ImaginaryDevelopmenthttp://fssnip.net/authors/ImaginaryDevelopment and is available under the Microsoft Public Licensehttp://opensource.org/licenses/ms-pl.

LinkDemand

for full trust for the immediate caller. This class cannot be used by partially trusted code.

InheritanceDemand

for full trust for inheritors. This class cannot be inherited by partially trusted code.

.NET Framework
Disponible depuis 1.1

Tous les membres statiques publics ( Shared en Visual Basic) de ce type sont thread-safe. Les membres d’instance n’ont pas la garantie d’être thread-safe.

Retour au début
Afficher: