Wie man parent-Prozess .NET in der verwalteten Weg

Hier ist eine Lösung. Es nutzt p/invoke, aber scheint gut zu funktionieren, 32 oder 64 cpu:

    ///<summary>
    ///A utility class to determine a process parent.
    ///</summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct ParentProcessUtilities
    {
        //These members must match PROCESS_BASIC_INFORMATION
        internal IntPtr Reserved1;
        internal IntPtr PebBaseAddress;
        internal IntPtr Reserved2_0;
        internal IntPtr Reserved2_1;
        internal IntPtr UniqueProcessId;
        internal IntPtr InheritedFromUniqueProcessId;

        [DllImport("ntdll.dll")]
        private static extern int NtQueryInformationProcess(IntPtr processHandle, int processInformationClass, ref ParentProcessUtilities processInformation, int processInformationLength, out int returnLength);

        ///<summary>
        ///Gets the parent process of the current process.
        ///</summary>
        ///<returns>An instance of the Process class.</returns>
        public static Process GetParentProcess()
        {
            return GetParentProcess(Process.GetCurrentProcess().Handle);
        }

        ///<summary>
        ///Gets the parent process of specified process.
        ///</summary>
        ///<param name="id">The process id.</param>
        ///<returns>An instance of the Process class.</returns>
        public static Process GetParentProcess(int id)
        {
            Process process = Process.GetProcessById(id);
            return GetParentProcess(process.Handle);
        }

        ///<summary>
        ///Gets the parent process of a specified process.
        ///</summary>
        ///<param name="handle">The process handle.</param>
        ///<returns>An instance of the Process class.</returns>
        public static Process GetParentProcess(IntPtr handle)
        {
            ParentProcessUtilities pbi = new ParentProcessUtilities();
            int returnLength;
            int status = NtQueryInformationProcess(handle, 0, ref pbi, Marshal.SizeOf(pbi), out returnLength);
            if (status != 0)
                throw new Win32Exception(status);

            try
            {
                return Process.GetProcessById(pbi.InheritedFromUniqueProcessId.ToInt32());
            }
            catch (ArgumentException)
            {
                //not found
                return null;
            }
        }
    }

InformationsquelleAutor Simon Mourier

Hier mein Versuch bei einer verwalteten Lösung.

Er fragt die Leistungsindikatoren für alle Prozesse und gibt ein Lexikon, Kind-PID an Eltern-PID. Dann können Sie das Wörterbuch mit Ihrem aktuellen PID, um zu sehen, Ihre Eltern, Großeltern, etc.

Ist es übertrieben, wie viel Informationen es bekommt, das ist sicher. Fühlen Sie sich frei, zu optimieren.

using System;
using System.Collections.Generic;
using System.Diagnostics;

namespace PidExamples
{
    class ParentPid
    {
        static void Main(string[] args)
        {
            var childPidToParentPid = GetAllProcessParentPids();
            int currentProcessId = Process.GetCurrentProcess().Id;

            Console.WriteLine("Current Process ID: " + currentProcessId);
            Console.WriteLine("Parent Process ID: " + childPidToParentPid[currentProcessId]);
        }

        public static Dictionary<int, int> GetAllProcessParentPids()
        {
            var childPidToParentPid = new Dictionary<int, int>();

            var processCounters = new SortedDictionary<string, PerformanceCounter[]>();
            var category = new PerformanceCounterCategory("Process");

            //As the base system always has more than one process running, 
            //don't special case a single instance return.
            var instanceNames = category.GetInstanceNames();
            foreach(string t in instanceNames)
            {
                try
                {
                    processCounters[t] = category.GetCounters(t);
                }
                catch (InvalidOperationException)
                {
                    //Transient processes may no longer exist between 
                    //GetInstanceNames and when the counters are queried.
                }
            }

            foreach (var kvp in processCounters)
            {
                int childPid = -1;
                int parentPid = -1;

                foreach (var counter in kvp.Value)
                {
                    if ("ID Process".CompareTo(counter.CounterName) == 0)
                    {
                        childPid = (int)(counter.NextValue());
                    }
                    else if ("Creating Process ID".CompareTo(counter.CounterName) == 0)
                    {
                        parentPid = (int)(counter.NextValue());
                    }
                }

                if (childPid != -1 && parentPid != -1)
                {
                    childPidToParentPid[childPid] = parentPid;
                }
            }

            return childPidToParentPid;
        }
    }
}    

In anderen news, ich habe gelernt, wie viele Leistungsindikatoren gab es auf meinem Rechner: 13401. Heilige Kuh.

InformationsquelleAutor Jeremy Murray

Wenn Sie jemals gegraben des BCL, so werdet Ihr finden, dass die Wege zu finden, übergeordneten Prozess bewusst vermieden, nehmen Sie dies zum Beispiel:

https://referencesource.microsoft.com/#System/services/monitoring/system/diagnosticts/ProcessManager.cs,327

Wie Sie sehen können, in den source-code, es enthält umfassende Strukturen und importiert native Methoden sind absolut ausreichend, um den job zu erledigen. Jedoch, selbst wenn Sie Zugriff per reflection(das ist möglich), würden Sie nicht eine Methode finden, es zu tun direkt. Ich kann nicht beantworten, warum, aber dieses Phänomen bewirkt, dass Fragen wie deine, werden gebeten, sich für etwas wiederholt; zum Beispiel:

Wie bekomme ich die PID des übergeordneten Prozesses, dass meine Bewerbung

Für die gibt es keine Antwort, zusammen mit einigen code mit CreateToolhelp32Snapshot in diesem thread, würde ich es hinzufügen-Teil der Struktur-Definitionen und Namen, die ich stehlen, von der MS " Referenz-Quelle 🙂

• Code

  using System.Diagnostics;
  using System.Runtime.InteropServices;
  using System.Collections.Generic;
  using System.Linq;
  using System;

  ---

  public static class Toolhelp32 {
      public const uint Inherit = 0x80000000;
      public const uint SnapModule32 = 0x00000010;
      public const uint SnapAll = SnapHeapList|SnapModule|SnapProcess|SnapThread;
      public const uint SnapHeapList = 0x00000001;
      public const uint SnapProcess = 0x00000002;
      public const uint SnapThread = 0x00000004;
      public const uint SnapModule = 0x00000008;
  
      [DllImport("kernel32.dll")]
      static extern bool CloseHandle(IntPtr handle);
      [DllImport("kernel32.dll")]
      static extern IntPtr CreateToolhelp32Snapshot(uint flags, int processId);
  
      public static IEnumerable<T> TakeSnapshot<T>(uint flags, int id) where T : IEntry, new() {
          using(var snap = new Snapshot(flags, id))
              for(IEntry entry = new T { }; entry.TryMoveNext(snap, out entry);)
                  yield return (T)entry;
      }
  
      public interface IEntry {
          bool TryMoveNext(Toolhelp32.Snapshot snap, out IEntry entry);
      }
  
      public struct Snapshot:IDisposable {
          void IDisposable.Dispose() {
              Toolhelp32.CloseHandle(m_handle);
          }
          public Snapshot(uint flags, int processId) {
              m_handle=Toolhelp32.CreateToolhelp32Snapshot(flags, processId);
          }
          IntPtr m_handle;
      }
  }

  ---

  [StructLayout(LayoutKind.Sequential)]
  public struct WinProcessEntry:Toolhelp32.IEntry {
      [DllImport("kernel32.dll")]
      public static extern bool Process32Next(Toolhelp32.Snapshot snap, ref WinProcessEntry entry);
  
      public bool TryMoveNext(Toolhelp32.Snapshot snap, out Toolhelp32.IEntry entry) {
          var x = new WinProcessEntry { dwSize=Marshal.SizeOf(typeof(WinProcessEntry)) };
          var b = Process32Next(snap, ref x);
          entry=x;
          return b;
      }
  
      public int dwSize;
      public int cntUsage;
      public int th32ProcessID;
      public IntPtr th32DefaultHeapID;
      public int th32ModuleID;
      public int cntThreads;
      public int th32ParentProcessID;
      public int pcPriClassBase;
      public int dwFlags;
      [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
      public String fileName;
      //byte fileName[260];
      //public const int sizeofFileName = 260;
  }

  ---

  public static class Extensions {
      public static Process Parent(this Process p) {
          var entries = Toolhelp32.TakeSnapshot<WinProcessEntry>(Toolhelp32.SnapAll, 0);
          var parentid = entries.First(x => x.th32ProcessID==p.Id).th32ParentProcessID;
          return Process.GetProcessById(parentid);
      }
  }

Und wir können es verwenden, wie:

• Test

  public class TestClass {
      public static void TestMethod() {
          var p = Process.GetCurrentProcess().Parent();
          Console.WriteLine("{0}", p.Id);
      }
  }

Für alternative enden ..

Laut der Dokumentation gibt es ein paar Methoden iteration pro Typ der Eingaben, wie Process32First und Process32Next sind für die iteration der Prozesse; aber ich fand die `xxxxFirst " Methoden überflüssig sind, und dann dachte ich, warum nicht setzen die iteration-Methode mit dem entsprechenden Eintrag geben? Es wäre leichter zu implementieren und verstanden zu werden(vermute ich mal so ..).

Nur als Toolhelp32 Suffix helfen, ich denke, dass eine statische helper-Klasse die richtige ist, so dass wir die klare qualifizierten Namen wie Toolhelp32.Snapshot oder Toolhelp32.IEntry obwohl es wäre hier irrelevant ..

Wenn der parent-Prozess ist gewonnen, wenn Sie weiter wollen, erhalten ausführliche infos, können Sie erweitern mit dieser leicht zu, zum Beispiel, die Iteration über die Module, dann fügen Sie hinzu:

• Code - WinModuleEntry

  [StructLayout(LayoutKind.Sequential)]
  public struct WinModuleEntry:Toolhelp32.IEntry { //MODULEENTRY32
      [DllImport("kernel32.dll")]
      public static extern bool Module32Next(Toolhelp32.Snapshot snap, ref WinModuleEntry entry);
  
      public bool TryMoveNext(Toolhelp32.Snapshot snap, out Toolhelp32.IEntry entry) {
          var x = new WinModuleEntry { dwSize=Marshal.SizeOf(typeof(WinModuleEntry)) };
          var b = Module32Next(snap, ref x);
          entry=x;
          return b;
      }
  
      public int dwSize;
      public int th32ModuleID;
      public int th32ProcessID;
      public int GlblcntUsage;
      public int ProccntUsage;
      public IntPtr modBaseAddr;
      public int modBaseSize;
      public IntPtr hModule;
      //byte moduleName[256];
      [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
      public string moduleName;
      [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
      public string fileName;
      //byte fileName[260];
      //public const int sizeofModuleName = 256;
      //public const int sizeofFileName = 260;
  }

  ---

  und einige testen ..

  public class TestClass {
      public static void TestMethod() {
          var p = Process.GetCurrentProcess().Parent();
          Console.WriteLine("{0}", p.Id);
  
          var formatter = new CustomFormatter { };
          foreach(var x in Toolhelp32.TakeSnapshot<WinModuleEntry>(Toolhelp32.SnapModule, p.Id)) {
              Console.WriteLine(String.Format(formatter, "{0}", x));
          }
      }
  }
  
  public class CustomFormatter:IFormatProvider, ICustomFormatter {
      String ICustomFormatter.Format(String format, object arg, IFormatProvider formatProvider) {
          var type = arg.GetType();
          var fields = type.GetFields();
          var q = fields.Select(x => String.Format("{0}:{1}", x.Name, x.GetValue(arg)));
          return String.Format("{{{0}}}", String.Join(", ", q.ToArray()));
      }
  
      object IFormatProvider.GetFormat(Type formatType) {
          return typeof(ICustomFormatter)!=formatType ? null : this;
      }
  }

In Fall, dass Sie ein code-Beispiel ..

• https://github.com/kenkins/ToolHelp32ConsoleApp

InformationsquelleAutor Ken Kin