Obtention de l'ID de thread à partir d'un thread

En C # lors du débogage de threads par exemple, vous pouvez voir l'ID de chaque thread.

Je n'ai pas pu trouver un moyen d'obtenir ce même fil, par programme. Je n'ai même pas pu obtenir l'ID du thread actuel (dans les propriétés du Thread.currentThread).

Donc, je me demande comment Visual Studio obtient les ID des threads, et est-il possible d'obtenir le handle du thread avec id 2345, par exemple?

GetThreadIdrenvoie l'ID d'un thread natif donné. Il existe des moyens de le faire fonctionner avec des threads gérés, je suis sûr, tout ce que vous devez trouver est le handle de thread et le transmettre à cette fonction.

GetCurrentThreadId renvoie l'ID du thread actuel.

GetCurrentThreadIdest obsolète depuis .NET 2.0: la méthode recommandée est la Thread.CurrentThread.ManagedThreadIdpropriété.

En C # lors du débogage de threads par exemple, vous pouvez voir l'ID de chaque thread.

Ce seront les identifiants des threads gérés. ManagedThreadIdest membre de Threadvous pouvez donc obtenir l'ID à partir de n'importe quel objet Thread . Cela vous donnera le ManagedThreadID actuel :

Thread.CurrentThread.ManagedThreadId

Pour obtenir un thread OS par son ID de thread OS (pas ManagedThreadID) , vous pouvez essayer un peu de linq.

int unmanagedId = 2345;
ProcessThread myThread = (from ProcessThread entry in Process.GetCurrentProcess().Threads
   where entry.Id == unmanagedId 
   select entry).First();

Il semble qu'il n'y ait aucun moyen d'énumérer les threads gérés et aucune relation entre ProcessThread et Thread, donc obtenir un thread géré par son ID est difficile.

Pour plus de détails sur le filetage géré vs non géré, consultez cet article MSDN .

Vous pouvez utiliser le obsolète AppDomain.GetCurrentThreadIdpour obtenir l'ID du thread en cours d'exécution. Cette méthode utilise un PInvoke à la méthode API Win32 GetCurrentThreadIDet renverra l'ID de thread Windows.

Cette méthode est marquée comme obsolète car l'objet .NET Thread ne correspond pas à un seul thread Windows, et en tant que tel, il n'y a pas d'ID stable qui peut être renvoyé par Windows pour un thread .NET donné.

Voir la réponse du configurateur pour plus de raisons pour lesquelles c'est le cas.

Pour obtenir l'ID du système d'exploitation, utilisez:

AppDomain.GetCurrentThreadId()

Selon MSDN :

Un ThreadId du système d'exploitation n'a pas de relation fixe avec un thread géré, car un hôte non géré peut contrôler la relation entre les threads gérés et non gérés. Plus précisément, un hôte sophistiqué peut utiliser l'API d'hébergement CLR pour planifier de nombreux threads gérés par rapport au même thread du système d'exploitation, ou pour déplacer un thread géré entre différents threads du système d'exploitation.

Donc, fondamentalement, l' Threadobjet ne correspond pas nécessairement à un thread OS - c'est pourquoi il n'a pas l'ID natif exposé.

Pour ceux sur le point de pirater:

    public static int GetNativeThreadId(Thread thread)
    {
        var f = typeof(Thread).GetField("DONT_USE_InternalThread",
            BindingFlags.GetField | BindingFlags.NonPublic | BindingFlags.Instance);

        var pInternalThread = (IntPtr)f.GetValue(thread);
        var nativeId = Marshal.ReadInt32(pInternalThread, (IntPtr.Size == 8) ? 548 : 348); // found by analyzing the memory
        return nativeId;
    }

Pour trouver l'ID de thread actuel, utilisez - `Thread.CurrentThread.ManagedThreadId '. Mais dans ce cas, vous pourriez avoir besoin de l'ID de thread Win32 actuel - utilisez pInvoke pour l'obtenir avec cette fonction:

[DllImport("Kernel32", EntryPoint = "GetCurrentThreadId", ExactSpelling = true)]
public static extern Int32 GetCurrentWin32ThreadId();

Vous devez d'abord enregistrer l'ID de thread géré et la connexion d'ID de thread win32 - utilisez un dictionnaire qui mappe un identifiant win32 sur le thread géré.

Ensuite, pour rechercher un thread par son id, parcourez le thread du processus à l'aide de Process.GetCurrentProcess (). Threads et recherchez le thread avec cet id:

foreach (ProcessThread thread in Process.GetCurrentProcess().Threads)
{
     var managedThread = win32ToManagedThread[thread.id];
     if((managedThread.ManagedThreadId == threadId)
     {
         return managedThread;
     }
}

Le décalage sous Windows 10 est 0x022C (application x64 bits) et 0x0160 (application x32 bits):

public static int GetNativeThreadId(Thread thread)
{
    var f = typeof(Thread).GetField("DONT_USE_InternalThread",
        BindingFlags.GetField | BindingFlags.NonPublic | BindingFlags.Instance);

    var pInternalThread = (IntPtr)f.GetValue(thread);
    var nativeId = Marshal.ReadInt32(pInternalThread, (IntPtr.Size == 8) ? 0x022C : 0x0160); // found by analyzing the memory
    return nativeId;
}

System.Threading.Thread.CurrentThread.Name

System.Threading.Thread.CurrentThread.ManagedThreadId

A partir du code managé, vous avez accès aux instances du Threadtype pour chaque thread managé. Threadencapsule le concept d'un thread OS et depuis le CLR actuel, il existe une correspondance biunivoque avec les threads gérés et les threads OS. Cependant, il s'agit d'un détail de mise en œuvre, qui pourrait changer à l'avenir.

L'ID affiché par Visual Studio est en fait l'ID de thread du système d'exploitation. Ce n'est pas la même chose que l'ID de thread géré comme suggéré par plusieurs réponses.

Le Threadtype inclut un champ membre IntPtr privé appelé DONT_USE_InternalThread, qui pointe vers la structure du système d'exploitation sous-jacent. Cependant, comme il s'agit vraiment d'un détail de mise en œuvre, il n'est pas conseillé de poursuivre cette OMI. Et le nom indique en quelque sorte que vous ne devriez pas vous fier à cela.

Vous pouvez utiliser Thread.GetHashCode, qui renvoie l'ID de thread géré. Si vous pensez à l'objectif de GetHashCode, cela a du bon sens - il doit s'agir d'un identifiant unique (par exemple, la clé d'un dictionnaire) pour l'objet (le thread).

La source de référence pour la classe Thread est instructive ici. (Certes, une implémentation particulière de .NET peut ne pas être basée sur ce code source, mais à des fins de débogage, je vais tenter ma chance.)

GetHashCode "fournit ce code de hachage pour les algorithmes qui nécessitent des vérifications rapides de l'égalité des objets", il est donc bien adapté pour vérifier l'égalité des threads - par exemple pour affirmer qu'une méthode particulière s'exécute sur le thread à partir duquel vous souhaitez qu'elle soit appelée.