Timeout Class
Collapse the table of content
Expand the table of content

Timeout Class


Contains constants that specify infinite time-out intervals. This class cannot be inherited.

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


public ref class Timeout abstract sealed 


A constant used to specify an infinite waiting period, for threading methods that accept an Int32 parameter.


A constant used to specify an infinite waiting period, for methods that accept a TimeSpan parameter.

The members of this class are used to specify infinite time-out intervals in threading operations. Infinite is used by methods that accept an integer millisecondsTimeout parameter, such as Thread::Sleep(Int32), Thread::Join(Int32), and ReaderWriterLock::AcquireReaderLock(Int32). InfiniteTimeSpan is used by methods that accept a timeout parameter of type TimeSpan, such as Thread::Sleep(TimeSpan), Thread::Join(TimeSpan), and ReaderWriterLock::AcquireReaderLock(TimeSpan).

The following example shows a thread going to sleep for an infinite time and subsequently being woken up.

using namespace System;
using namespace System::Security::Permissions;
using namespace System::Threading;

ref class StayAwake
   bool sleepSwitch;


   property bool SleepSwitch 
      void set( bool value )
         sleepSwitch = value;

      sleepSwitch = false;

   void ThreadMethod()
      Console::WriteLine( "newThread is executing ThreadMethod." );
      while (  !sleepSwitch )

         // Use SpinWait instead of Sleep to demonstrate the 
         // effect of calling Interrupt on a running thread.
         Thread::SpinWait( 10000000 );

         Console::WriteLine( "newThread going to sleep." );

         // When newThread goes to sleep, it is immediately 
         // woken up by a ThreadInterruptedException.
         Thread::Sleep( Timeout::Infinite );
      catch ( ThreadInterruptedException^ /*e*/ ) 
         Console::WriteLine( "newThread cannot go to sleep - "
         "interrupted by main thread." );



int main()
   StayAwake^ stayAwake = gcnew StayAwake;
   Thread^ newThread = gcnew Thread( gcnew ThreadStart( stayAwake, &StayAwake::ThreadMethod ) );

   // The following line causes an exception to be thrown 
   // in ThreadMethod if newThread is currently blocked
   // or becomes blocked in the future.
   Console::WriteLine( "Main thread calls Interrupt on newThread." );

   // Then tell newThread to go to sleep.
   stayAwake->SleepSwitch = true;

   // Wait for newThread to end.

Universal Windows Platform
Available since 8
.NET Framework
Available since 1.1
Portable Class Library
Supported in: portable .NET platforms
Available since 2.0
Windows Phone Silverlight
Available since 7.0
Windows Phone
Available since 8.1

This type is thread safe.

Return to top
© 2016 Microsoft