Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original
Este tópico ainda não foi avaliado como - Avalie este tópico

Classe Timeout

Contém uma constante usada para especificar uma quantidade infinita de time. Esta classe não pode ser herdada.

Namespace:  System.Threading
Assembly:  mscorlib (em mscorlib.dll)
[ComVisibleAttribute(true)]
public static class Timeout

O único membro dessa classe, Infinite, é uma constante usada pelos métodos que aceitam um número inteiro timeout parâmetro, tal sistema autônomo Thread.Sleep(Int32), Thread.Join(Int32), e ReaderWriterLock.AcquireReaderLock(Int32).

O exemplo de código a seguir mostra um contínuo de thread em suspensão por um período infinito e, em seguida, sendo woken.

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

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

class ThreadInterrupt
{
    staticvoid 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;

    publicbool SleepSwitch
    {
        set{ sleepSwitch = value; }
    }

    public StayAwake(){}

    publicvoid 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

Esse tipo é segmento seguro.

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

o.NET Framework e.NET Compact Framework não oferecem suporte a todas as versões de cada plataforma. Para obter uma lista de versões suportadas, consulte Requisitos de sistema do .NET framework.

.NET Framework

Compatível com: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Compatível com: 3.5, 2.0, 1.0

XNA Framework

Compatível com: , 1.0
Isso foi útil para você?
(1500 caracteres restantes)
Agradecemos os seus comentários

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2014 Microsoft. Todos os direitos reservados.