ApartmentState Énumération

Définition

Espace de noms:

System.Threading

Assembly:

System.Threading.Thread.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Spécifie l'état apartment (cloisonné) de Thread.

public enum class ApartmentState

public enum ApartmentState

[System.Serializable]
public enum ApartmentState

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public enum ApartmentState

type ApartmentState = 

[<System.Serializable>]
type ApartmentState = 

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ApartmentState = 

Public Enum ApartmentState

Héritage

Object

ValueType

Enum

ApartmentState

Attributs

SerializableAttribute ComVisibleAttribute

Champs

MTA	1	Thread crée et entre un apartment (cloisonné) MTA (multithreaded apartment).
STA	0	Thread crée et entre un thread cloisonné STA (single thread apartment).
Unknown	2	La propriété ApartmentState n'a pas été définie.

Exemples

L’exemple de code suivant montre comment définir l’état d’appartement d’un thread.

using namespace System;
using namespace System::Threading;
ref class ApartmentTest
{
public:
   static void ThreadMethod()
   {
      Thread::Sleep( 1000 );
   }

};

int main()
{
   Thread^ newThread = gcnew Thread( gcnew ThreadStart( &ApartmentTest::ThreadMethod ) );
   newThread->SetApartmentState(ApartmentState::MTA);
   
   Console::WriteLine( "ThreadState: {0}, ApartmentState: {1}", newThread->ThreadState.ToString(), newThread->GetApartmentState().ToString() );
   newThread->Start();
   
   // Wait for newThread to start and go to sleep.
   Thread::Sleep( 300 );
   try
   {
      
      // This causes an exception since newThread is sleeping.
      newThread->SetApartmentState(ApartmentState::STA);
   }
   catch ( ThreadStateException^ stateException ) 
   {
      Console::WriteLine( "\n{0} caught:\n"
      "Thread is not in the Unstarted or Running state.", stateException->GetType()->Name );
      Console::WriteLine( "ThreadState: {0}, ApartmentState: {1}", newThread->ThreadState.ToString(), newThread->GetApartmentState().ToString() );
   }

}

using System;
using System.Threading;

class ApartmentTest
{
    static void Main()
    {
        Thread newThread = 
            new Thread(new ThreadStart(ThreadMethod));
        newThread.SetApartmentState(ApartmentState.MTA);

        Console.WriteLine("ThreadState: {0}, ApartmentState: {1}", 
            newThread.ThreadState, newThread.GetApartmentState());

        newThread.Start();

        // Wait for newThread to start and go to sleep.
        Thread.Sleep(300);
        try
        {
            // This causes an exception since newThread is sleeping.
            newThread.SetApartmentState(ApartmentState.STA);
        }
        catch(ThreadStateException stateException)
        {
            Console.WriteLine("\n{0} caught:\n" +
                "Thread is not in the Unstarted or Running state.", 
                stateException.GetType().Name);
            Console.WriteLine("ThreadState: {0}, ApartmentState: {1}",
                newThread.ThreadState, newThread.GetApartmentState());
        }
    }

    static void ThreadMethod()
    {
        Thread.Sleep(1000);
    }
}

Imports System.Threading

Public Class ApartmentTest

    <MTAThread> _
    Shared Sub Main()
    
        Dim newThread As Thread = New Thread(AddressOf ThreadMethod)
        newThread.SetApartmentState(ApartmentState.MTA)

        Console.WriteLine("ThreadState: {0}, ApartmentState: {1}", _
            newThread.ThreadState, newThread.GetApartmentState())

        newThread.Start()

        ' Wait for newThread to start and go to sleep.
        Thread.Sleep(300)
        Try
            ' This causes an exception since newThread is sleeping.
            newThread.SetApartmentState(ApartmentState.STA)
        Catch stateException As ThreadStateException
            Console.WriteLine(vbCrLf & "{0} caught:" & vbCrLf & _
                "Thread is not In the Unstarted or Running state.", _
                stateException.GetType().Name)
            Console.WriteLine("ThreadState: {0}, ApartmentState: " & _
                "{1}", newThread.ThreadState, newThread.GetApartmentState())
        End Try

    End Sub

    Shared Sub ThreadMethod()
        Thread.Sleep(1000)
    End Sub

End Class

Remarques

Un appartement est un conteneur logique au sein d’un processus pour les objets partageant les mêmes exigences d’accès au thread. Tous les objets du même appartement peuvent recevoir des appels de n’importe quel thread dans l’appartement. Le .NET Framework n’utilise pas d’appartements et les objets gérés sont responsables de l’utilisation de toutes les ressources partagées de manière sécurisée eux-mêmes.

Étant donné que les classes COM utilisent des appartements, le Common Language Runtime doit créer et initialiser un appartement lors de l’appel d’un objet COM dans une situation d’interopérabilité COM. Un thread managé peut créer et entrer un appartement à thread unique (STA) qui autorise un seul thread ou un appartement multithread (MTA) qui contient un ou plusieurs threads. Vous pouvez contrôler le type d’appartement créé en définissant la ApartmentState propriété du thread sur l’une des valeurs de l’énumération ApartmentState . Étant donné qu’un thread donné ne peut initialiser qu’un appartement COM une seule fois, vous ne pouvez pas modifier le type d’appartement après le premier appel au code non managé.

Pour plus d’informations, consultez Thread, Threading managé et non managé et Interopérabilité COM avancée.

Voir aussi

• Thread