Exemple de code d'analyse de la suspension et de la récupération des processus en C# (image)

Cet article présente principalement la méthode de suspension et de reprise des processus en C# Il est très bien et a une valeur de référence. Les amis dans le besoin peuvent s'y référer

1. Origine :

est toujours la demande provoquée par la

modularisationprogrammation. Les chefs de produit sont difficiles à servir, et les femmes chefs de produit sont encore plus difficiles~:p

C'est purement une blague, la solution technique n'a rien à voir avec le chef de produit, ne blâmez pas Taro !

La reconstruction du projet VCU10 nécessite que chaque module fonctionnel soit implémenté dans un processus indépendant. Par exemple, si le module de conversion audio et vidéo est implémenté dans un processus indépendant, comment contrôler sa pause, sa poursuite et ses autres fonctions ?

Les threads peuvent être suspendus et repris, mais le processus intégré en C# ne dispose pas de telles méthodes. Que dois-je faire ?

Les montagnes et les rivières sont épuisées et il n'y a pas d'issue, mais il y a un autre village avec des saules sombres et des fleurs lumineuses. Lorsque l’amour devient fort, il devient clair et devient faible. Cet amour peut être rappelé dans la mémoire !

L'article précédent décrivait la méthode de transfert de données inter-processus, et cet article utilise également des exemples pour démontrer les méthodes de contrôle et d'interaction des données.

2. Fonctions API non publiées : NtSuspendProcess, NtResumeProcess

De telles fonctions sont introuvables dans MSDN.

La raison est qu'ils se situent entre l'API Windows et l'API du noyau, et leur puissance ne peut être sous-estimée. J'avais peur que les programmeurs de 28 Rakes puissent en abuser et causer des problèmes, alors je l'ai caché secrètement.

En fait, il existe également NtTerminateProcess. Puisque Process a une méthode Kill, elle n'est pas nécessaire.

Mais peu importe à quel point quelque chose est secret, tant qu'il a de la valeur, il sera creusé par d'autres. Le bon vin n'a pas peur des ruelles profondes !

D'accord, sur cette base, concevez un cours de gestion de processus pour réaliser le besoin de contrôle inter-processus de la programmation modulaire.

3. ProcessMgr

Passons directement au code et encapsulons une unité de gestion de processus :

public static class ProcessMgr
 {
  /// <summary>
  /// The process-specific access rights.
  /// </summary>
  [Flags]
  public enum ProcessAccess : uint
  {
   /// <summary>
   /// Required to terminate a process using TerminateProcess.
   /// </summary>
   Terminate = 0x1,
   /// <summary>
   /// Required to create a thread.
   /// </summary>
   CreateThread = 0x2,
   /// <summary>
   /// Undocumented.
   /// </summary>
   SetSessionId = 0x4,
   /// <summary>
   /// Required to perform an operation on the address space of a process (see VirtualProtectEx and WriteProcessMemory).
   /// </summary>
   VmOperation = 0x8,
   /// <summary>
   /// Required to read memory in a process using ReadProcessMemory.
   /// </summary>
   VmRead = 0x10,
   /// <summary>
   /// Required to write to memory in a process using WriteProcessMemory.
   /// </summary>
   VmWrite = 0x20,
   /// <summary>
   /// Required to duplicate a handle using DuplicateHandle.
   /// </summary>
   DupHandle = 0x40,
   /// <summary>
   /// Required to create a process.
   /// </summary>
   CreateProcess = 0x80,
   /// <summary>
   /// Required to set memory limits using SetProcessWorkingSetSize.
   /// </summary>
   SetQuota = 0x100,
   /// <summary>
   /// Required to set certain information about a process, such as its priority class (see SetPriorityClass).
   /// </summary>
   SetInformation = 0x200,
   /// <summary>
   /// Required to retrieve certain information about a process, such as its token, exit code, and 
   priority class (see OpenProcessToken, GetExitCodeProcess, GetPriorityClass, and IsProcessInJob).
   /// </summary>
   QueryInformation = 0x400,
   /// <summary>
   /// Undocumented.
   /// </summary>
   SetPort = 0x800,
   /// <summary>
   /// Required to suspend or resume a process.
   /// </summary>
   SuspendResume = 0x800,
   /// <summary>
   /// Required to retrieve certain information about a process (see QueryFullProcessImageName). 
   A handle that has the PROCESS_QUERY_INFORMATION access right is automatically granted PROCESS_QUERY_LIMITED_INFORMATION.
   /// </summary>
   QueryLimitedInformation = 0x1000,
   /// <summary>
   /// Required to wait for the process to terminate using the wait functions.
   /// </summary>
   Synchronize = 0x100000
  }
  [DllImport("ntdll.dll")]
  private static extern uint NtResumeProcess([In] IntPtr processHandle);
  [DllImport("ntdll.dll")]
  private static extern uint NtSuspendProcess([In] IntPtr processHandle);
  [DllImport("kernel32.dll", SetLastError = true)]
  private static extern IntPtr OpenProcess(
   ProcessAccess desiredAccess,
   bool inheritHandle,
   int processId);
  [DllImport("kernel32.dll", SetLastError = true)]
  [return: MarshalAs(UnmanagedType.Bool)]
  private static extern bool CloseHandle([In] IntPtr handle);
  public static void SuspendProcess(int processId)
  {
   IntPtr hProc = IntPtr.Zero;
   try
   {
    // Gets the handle to the Process
    hProc = OpenProcess(ProcessAccess.SuspendResume, false, processId);
    if (hProc != IntPtr.Zero)
     NtSuspendProcess(hProc);
   }
   finally
   {
    // Don&#39;t forget to close handle you created.
    if (hProc != IntPtr.Zero)
     CloseHandle(hProc);
   }
  }
  public static void ResumeProcess(int processId)
  {
   IntPtr hProc = IntPtr.Zero;
   try
   {
    // Gets the handle to the Process
    hProc = OpenProcess(ProcessAccess.SuspendResume, false, processId);
    if (hProc != IntPtr.Zero)
     NtResumeProcess(hProc);
   }
   finally
   {
    // Don&#39;t forget to close handle you created.
    if (hProc != IntPtr.Zero)
     CloseHandle(hProc);
   }
  }
 }

4. Contrôle du processus

Nous avons le processus principal comme hôte. Il appelle le processus enfant via la classe Process pour obtenir son identifiant et l'utiliser à cette fin. Le code d'appel est :

 private void RunTestProcess(bool hidden = false)
  {
   string appPath = Path.GetDirectoryName(Application.ExecutablePath);
   string testAppPath = Path.Combine(appPath, "TestApp.exe");
   var pi = new ProcessStartInfo();
   pi.FileName = testAppPath;
   pi.Arguments = this.Handle.ToString();
   pi.WindowStyle = hidden ? ProcessWindowStyle.Hidden : ProcessWindowStyle.Normal;
   this.childProcess = Process.Start(pi);
   txtInfo.Text = string.Format("子进程ID：{0}\r\n子进程名：{1}", childProcess.Id, childProcess.ProcessName);
   ...
  }

Le code de contrôle est :

private void btnWork_Click(object sender, EventArgs e)
  {
   if (this.childProcess == null || this.childProcess.HasExited)
    return;
   if ((int)btnWork.Tag == 0)
   {
    btnWork.Tag = 1;
    btnWork.Text = "恢复";
    ProcessMgr.SuspendProcess(this.childProcess.Id);
   }
   else
   {
    btnWork.Tag = 0;
    btnWork.Text = "挂起";
    ProcessMgr.ResumeProcess(this.childProcess.Id);
   }
  }

Le sous-processus simule son travail avec un

minuterie et envoie des messages de progression au processus principal :

 private void timer_Tick(object sender, EventArgs e)
  {
   if (progressBar.Value < progressBar.Maximum)
    progressBar.Value += 1;
   else
    progressBar.Value = 0;
   if (this.hostHandle != IntPtr.Zero)
    SendMessage(this.hostHandle, WM_PROGRESS, 0, progressBar.Value);
  }

La quantité de code est si petite, simple...

Rendu :

À titre d'exemple, deux schémas sont réalisés, l'un montrant le sous-processus et l'autre montrant le sous-processus.

Le projet lui-même appelle le module de processus indépendant, qui est appelé de manière cachée, et l'hôte affiche la progression de son traitement, comme indiqué dans l'image :

Postscript :

En élargissant l'idée, d'excellents outils open source, tels que youtube_dl, ffmpeg, etc., existent en tant que processus indépendants et peuvent gérer la communication via CMD.

Avec ce principe de contrôle de processus, vous pouvez créer de très bons outils GUI basés sur ces outils open source. Après tout, comparées à la puissante ligne de commande, les gens considèrent toujours les opérations simples comme pratiques.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!