Freigeben über

Thread.ApartmentState-Eigenschaft

  • Artikel

HINWEIS: Diese Eigenschaft ist mittlerweile veraltet. Die nicht veraltete Alternative ist GetApartmentStateSetApartmentState.

Ruft den Apartmentzustand dieses Threads ab oder legt diesen fest.

Namespace: System.Threading
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
<ObsoleteAttribute("The ApartmentState property has been deprecated.  Use GetApartmentState, SetApartmentState or TrySetApartmentState instead.", False)> _
Public Property ApartmentState As ApartmentState
'Usage
Dim instance As Thread
Dim value As ApartmentState

value = instance.ApartmentState

instance.ApartmentState = value

[ObsoleteAttribute("The ApartmentState property has been deprecated.  Use GetApartmentState, SetApartmentState or TrySetApartmentState instead.", false)] 
public ApartmentState ApartmentState { get; set; }

[ObsoleteAttribute(L"The ApartmentState property has been deprecated.  Use GetApartmentState, SetApartmentState or TrySetApartmentState instead.", false)] 
public:
property ApartmentState ApartmentState {
    ApartmentState get ();
    void set (ApartmentState value);
}

/** @property */
public ApartmentState get_ApartmentState ()

/** @property */
public void set_ApartmentState (ApartmentState value)

public function get ApartmentState () : ApartmentState

public function set ApartmentState (value : ApartmentState)

Eigenschaftenwert

Einer der ApartmentState-Werte. Der Anfangswert ist Unknown.

Ausnahmen

Ausnahmetyp Bedingung

ArgumentException

Es wird versucht, diese Eigenschaft auf einen Zustand festzulegen, der kein gültiger Apartmentzustand ist, d. h. der nicht der Zustand Singlethreaded Apartment (STA) oder Multithreaded Apartment (MTA) ist.

Hinweise

In .NET Framework, Version 1.0 und 1.1, kennzeichnet die ApartmentState-Eigenschaft einen Thread, um anzugeben, dass er in einem Singlethread-Apartment oder einem Multithread-Apartment ausgeführt wird. Diese Eigenschaft kann festgelegt werden, wenn sich der Thread im Unstarted-Threadzustand oder im Running-Threadzustand befindet. Sie kann für einen Thread jedoch jeweils nur einmal festgelegt werden. Wenn die Eigenschaft nicht festgelegt wurde, wird Unknown zurückgegeben.

Wichtig

In .NET Framework, Version 2.0, werden neue Threads als ApartmentState.MTA initialisiert, wenn ihr Apartmentzustand vor dem Starten nicht festgelegt wurde. Der Hauptanwendungsthread wird standardmäßig mit ApartmentState.MTA initialisiert. Es ist nicht mehr möglich, den Hauptanwendungsthread auf ApartmentState.STA festzulegen, indem die System.Threading.ApartmentState-Eigenschaft in der ersten Codezeile festgelegt wird. Verwenden Sie stattdessen das STAThreadAttribute.

In .NET Framework, Version 2.0, können Sie das COM-Threadingmodell für eine C++-Anwendung mit der Linkeroption /CLRTHREADATTRIBUTE (Festlegen des CLR-Threadattributs) angeben.

Hinweis

Das auf diese Eigenschaft angewendete HostProtectionAttribute-Attribut besitzt den Resources-Eigenschaftenwert Synchronization | SelfAffectingThreading. Das HostProtectionAttribute hat keine Auswirkungen auf Desktopanwendungen (die normalerweise durch Doppelklicken auf ein Symbol, Eingeben eines Befehls oder eines URL in einem Browser gestartet werden). Weitere Informationen finden Sie unter der HostProtectionAttribute-Klasse oder unter SQL Server-Programmierung und Hostschutzattribute.

Beispiel

Das folgende Codebeispiel veranschaulicht das Festlegen des Apartmentzustands eines Threads.

Imports Microsoft.VisualBasic
Imports System
Imports System.Threading

Public Class ApartmentTest

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

        ' The following line is ignored since 
        ' ApartmentState can only be set once.
        newThread.SetApartmentState(ApartmentState.STA)

        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

using System;
using System.Threading;

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

        // The following line is ignored since 
        // ApartmentState can only be set once.
        newThread.SetApartmentState(ApartmentState.STA);

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

        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);
    }
}

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);
   
   // The following line is ignored since 
   // ApartmentState can only be set once.
   newThread->SetApartmentState(ApartmentState::STA);
   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() );
   }

}

import System.*;
import System.Threading.*;
import System.Threading.Thread;    

class ApartmentTest
{
    public static void main(String[] args)
    {
        Thread newThread = new Thread(new ThreadStart(ThreadMethod));

        newThread.set_ApartmentState(ApartmentState.MTA);

        // The following line is ignored since 
        // ApartmentState can only be set once.
        newThread.set_ApartmentState(ApartmentState.STA);
        Console.WriteLine("ThreadState: {0}, ApartmentState: {1}",
                        newThread.get_ThreadState(),
                        newThread.get_ApartmentState());
        newThread.Start();

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

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

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 1.0, 1.1
Veraltet (Compilerwarnung) in 2.0

Siehe auch

Referenz

Thread-Klasse
Thread-Member
System.Threading-Namespace
ThreadState