Export (0) Print
Expand All

Timeout Class

Contains a constant used to specify an infinite amount of time. This class cannot be inherited.

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

[ComVisibleAttribute(true)] 
public static class Timeout
/** @attribute ComVisibleAttribute(true) */ 
public final class Timeout
ComVisibleAttribute(true) 
public final class Timeout
Not applicable.

The only member of this class, Infinite, is a constant used by methods that accept an integer timeout parameter, such as Thread.Sleep(Int32), Thread.Join(Int32), and ReaderWriterLock.AcquireReaderLock(Int32).

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

using System;
using System.Security.Permissions;
using System.Threading;

[assembly: SecurityPermissionAttribute(SecurityAction.RequestMinimum,
    ControlThread = true)]

class ThreadInterrupt
{
    static void Main()
    {
        StayAwake stayAwake = new StayAwake();
        Thread newThread = 
            new Thread(new ThreadStart(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.");

        // Tell newThread to go to sleep.
        stayAwake.SleepSwitch = true;

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

class StayAwake
{
    bool sleepSwitch = false;

    public bool SleepSwitch
    {
        set{ sleepSwitch = value; }
    }

    public StayAwake(){}

    public 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.");
        }
    }
}

import System.*;
import System.Security.Permissions.*;
import System.Threading.*;
import System.Threading.Thread;

/** @assembly SecurityPermissionAttribute(SecurityAction.RequestMinimum,
    ControlThread = true)
 */

class ThreadInterrupt
{
    public static void main(String[] args)
    {
        StayAwake stayAwake =  new StayAwake();
        Thread newThread =  new Thread(new ThreadStart(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.");
      
        // Tell newThread to go to sleep.
        stayAwake.set_SleepSwitch(true);
      
        // Wait for newThread to end.
        newThread.Join();
   } //main
} //ThredInterrupt

class StayAwake
{
    private boolean sleepSwitch = false;

    /** @property
     */
    public void set_SleepSwitch(boolean value)
    {
        sleepSwitch = value;
    } //set_SleepSwitch

    public StayAwake()
    {
    } //StayAwake

    public 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 - " 
                + "nterrupted by main thread."));
        }
    } //ThreadMethod
} //StayAwake

System.Object
  System.Threading.Timeout

This type is thread safe.

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

The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.

.NET Framework

Supported in: 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 2.0, 1.0

XNA Framework

Supported in: 1.0

Community Additions

ADD
Show:
© 2014 Microsoft