Timeout Class
TOC
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)

System::Object
  System.Threading::Timeout

[ComVisibleAttribute(true)]
public ref class Timeout abstract sealed 

NameDescription
System_CAPS_pubfieldSystem_CAPS_staticInfinite

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

System_CAPS_pubfieldSystem_CAPS_staticInfiniteTimeSpan

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
{
private:
   bool sleepSwitch;

public:

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

   }
   StayAwake()
   {
      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 );
      }

      try
      {
         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 ) );
   newThread->Start();

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

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

   // Wait for newThread to end.
   newThread->Join();
}

Universal Windows Platform
Available since 8
.NET Framework
Available since 1.1
Portable Class Library
Supported in: portable .NET platforms
Silverlight
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
Show:
© 2016 Microsoft