Timer.Change 方法

参考

定义

命名空间:: System.Threading

程序集:: System.Threading.Timer.dll

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

更改计时器的启动时间和方法调用之间的间隔。

重载

Change(Int32, Int32)	更改计时器的启动时间和方法调用之间的间隔，用 32 位有符号整数度量时间间隔。
Change(Int64, Int64)	更改计时器的启动时间和方法调用之间的间隔，用 64 位有符号整数度量时间间隔。
Change(TimeSpan, TimeSpan)	更改计时器的启动时间和方法调用之间的时间间隔，使用 TimeSpan 值度量时间间隔。
Change(UInt32, UInt32)	更改计时器的启动时间和方法调用之间的间隔，用 32 位无符号整数度量时间间隔。

Change(Int32, Int32)

Source:: Timer.cs

Source:: Timer.cs

Source:: Timer.cs

更改计时器的启动时间和方法调用之间的间隔，用 32 位有符号整数度量时间间隔。

public:
 bool Change(int dueTime, int period);

public bool Change (int dueTime, int period);

member this.Change : int * int -> bool

Public Function Change (dueTime As Integer, period As Integer) As Boolean

参数

dueTime: Int32

在调用构造 Timer 时指定的回调方法之前的延迟时间量（以毫秒为单位）。指定 Infinite 可防止重新启动计时器。指定零 (0) 可立即重新启动计时器。

period: Int32

调用构造 Timer 时指定的回调方法的时间间隔（以毫秒为单位）。指定 Infinite 可以禁用定期终止。

Boolean

如果计时器更新成功，则为 true；否则为 false。

例外

ObjectDisposedException

Timer 已被释放。

ArgumentOutOfRangeException

dueTime 或 period 参数为负，并且不等于 Infinite。

示例

下面的代码示例演示如何启动， Timer 并在一定数量的调用后更改其周期。

using namespace System;
using namespace System::Threading;

ref class StatusChecker
{
private:
    int invokeCount, maxCount;

public:
    StatusChecker(int count)
    {
        invokeCount  = 0;
        maxCount = count;
    }

    // This method is called by the timer delegate.
    void CheckStatus(Object^ stateInfo)
    {
        AutoResetEvent^ autoEvent = dynamic_cast<AutoResetEvent^>(stateInfo);
        Console::WriteLine("{0:h:mm:ss.fff} Checking status {1,2}.",
                           DateTime::Now, ++invokeCount);

        if (invokeCount == maxCount) {
            // Reset the counter and signal the waiting thread.
            invokeCount  = 0;
            autoEvent->Set();
        }
    }
};

ref class TimerExample
{
public:
    static void Main()
    {
        // Create an AutoResetEvent to signal the timeout threshold in the
        // timer callback has been reached.
        AutoResetEvent^ autoEvent = gcnew AutoResetEvent(false);

        StatusChecker^ statusChecker = gcnew StatusChecker(10);

        // Create a delegate that invokes methods for the timer.
        TimerCallback^ tcb =
           gcnew TimerCallback(statusChecker, &StatusChecker::CheckStatus);

        // Create a timer that invokes CheckStatus after one second, 
        // and every 1/4 second thereafter.
        Console::WriteLine("{0:h:mm:ss.fff} Creating timer.\n",
                           DateTime::Now);
        Timer^ stateTimer = gcnew Timer(tcb, autoEvent, 1000, 250);

        // When autoEvent signals, change the period to every half second.
        autoEvent->WaitOne(5000, false);
        stateTimer->Change(0, 500);
        Console::WriteLine("\nChanging period to .5 seconds.\n");

        // When autoEvent signals the second time, dispose of the timer.
        autoEvent->WaitOne(5000, false);
        stateTimer->~Timer();
        Console::WriteLine("\nDestroying timer.");
    }
};

int main()
{
    TimerExample::Main();
}
// The example displays output like the following:
//       11:59:54.202 Creating timer.
//       
//       11:59:55.217 Checking status  1.
//       11:59:55.466 Checking status  2.
//       11:59:55.716 Checking status  3.
//       11:59:55.968 Checking status  4.
//       11:59:56.218 Checking status  5.
//       11:59:56.470 Checking status  6.
//       11:59:56.722 Checking status  7.
//       11:59:56.972 Checking status  8.
//       11:59:57.223 Checking status  9.
//       11:59:57.473 Checking status 10.
//       
//       Changing period to .5 seconds.
//       
//       11:59:57.474 Checking status  1.
//       11:59:57.976 Checking status  2.
//       11:59:58.476 Checking status  3.
//       11:59:58.977 Checking status  4.
//       11:59:59.477 Checking status  5.
//       11:59:59.977 Checking status  6.
//       12:00:00.478 Checking status  7.
//       12:00:00.980 Checking status  8.
//       12:00:01.481 Checking status  9.
//       12:00:01.981 Checking status 10.
//       
//       Destroying timer.

using System;
using System.Threading;

class TimerExample
{
    static void Main()
    {
        // Create an AutoResetEvent to signal the timeout threshold in the
        // timer callback has been reached.
        var autoEvent = new AutoResetEvent(false);
        
        var statusChecker = new StatusChecker(10);

        // Create a timer that invokes CheckStatus after one second, 
        // and every 1/4 second thereafter.
        Console.WriteLine("{0:h:mm:ss.fff} Creating timer.\n", 
                          DateTime.Now);
        var stateTimer = new Timer(statusChecker.CheckStatus, 
                                   autoEvent, 1000, 250);

        // When autoEvent signals, change the period to every half second.
        autoEvent.WaitOne();
        stateTimer.Change(0, 500);
        Console.WriteLine("\nChanging period to .5 seconds.\n");

        // When autoEvent signals the second time, dispose of the timer.
        autoEvent.WaitOne();
        stateTimer.Dispose();
        Console.WriteLine("\nDestroying timer.");
    }
}

class StatusChecker
{
    private int invokeCount;
    private int  maxCount;

    public StatusChecker(int count)
    {
        invokeCount  = 0;
        maxCount = count;
    }

    // This method is called by the timer delegate.
    public void CheckStatus(Object stateInfo)
    {
        AutoResetEvent autoEvent = (AutoResetEvent)stateInfo;
        Console.WriteLine("{0} Checking status {1,2}.", 
            DateTime.Now.ToString("h:mm:ss.fff"), 
            (++invokeCount).ToString());

        if(invokeCount == maxCount)
        {
            // Reset the counter and signal the waiting thread.
            invokeCount = 0;
            autoEvent.Set();
        }
    }
}
// The example displays output like the following:
//       11:59:54.202 Creating timer.
//       
//       11:59:55.217 Checking status  1.
//       11:59:55.466 Checking status  2.
//       11:59:55.716 Checking status  3.
//       11:59:55.968 Checking status  4.
//       11:59:56.218 Checking status  5.
//       11:59:56.470 Checking status  6.
//       11:59:56.722 Checking status  7.
//       11:59:56.972 Checking status  8.
//       11:59:57.223 Checking status  9.
//       11:59:57.473 Checking status 10.
//       
//       Changing period to .5 seconds.
//       
//       11:59:57.474 Checking status  1.
//       11:59:57.976 Checking status  2.
//       11:59:58.476 Checking status  3.
//       11:59:58.977 Checking status  4.
//       11:59:59.477 Checking status  5.
//       11:59:59.977 Checking status  6.
//       12:00:00.478 Checking status  7.
//       12:00:00.980 Checking status  8.
//       12:00:01.481 Checking status  9.
//       12:00:01.981 Checking status 10.
//       
//       Destroying timer.

Imports System.Threading

Public Module Example
    Public Sub Main()
        ' Use an AutoResetEvent to signal the timeout threshold in the
        ' timer callback has been reached.
        Dim autoEvent As New AutoResetEvent(False)

        Dim statusChecker As New StatusChecker(10)

        ' Create a timer that invokes CheckStatus after one second, 
        ' and every 1/4 second thereafter.
        Console.WriteLine("{0:h:mm:ss.fff} Creating timer." & vbCrLf, 
                          DateTime.Now)
        Dim stateTimer As New Timer(AddressOf statusChecker.CheckStatus, 
                                    autoEvent, 1000, 250)

        ' When autoEvent signals, change the period to every half second.
        autoEvent.WaitOne()
        stateTimer.Change(0, 500)
        Console.WriteLine(vbCrLf & "Changing period to .5 seconds." & vbCrLf)

        ' When autoEvent signals the second time, dispose of the timer.
        autoEvent.WaitOne()
        stateTimer.Dispose()
        Console.WriteLine(vbCrLf & "Destroying timer.")
    End Sub
End Module

Public Class StatusChecker
    Dim invokeCount, maxCount As Integer 

    Sub New(count As Integer)
        invokeCount  = 0
        maxCount = count
    End Sub

    ' The timer callback method.
    Sub CheckStatus(stateInfo As Object)
        Dim autoEvent As AutoResetEvent = DirectCast(stateInfo, AutoResetEvent)
        invokeCount += 1
        Console.WriteLine("{0:h:mm:ss.fff} Checking status {1,2}.", 
                          DateTime.Now, invokeCount)
        If invokeCount = maxCount Then
            ' Reset the counter and signal the waiting thread.
            invokeCount = 0
            autoEvent.Set()
        End If
    End Sub
End Class
' The example displays output like the following:
'       11:59:54.202 Creating timer.
'       
'       11:59:55.217 Checking status  1.
'       11:59:55.466 Checking status  2.
'       11:59:55.716 Checking status  3.
'       11:59:55.968 Checking status  4.
'       11:59:56.218 Checking status  5.
'       11:59:56.470 Checking status  6.
'       11:59:56.722 Checking status  7.
'       11:59:56.972 Checking status  8.
'       11:59:57.223 Checking status  9.
'       11:59:57.473 Checking status 10.
'       
'       Changing period to .5 seconds.
'       
'       11:59:57.474 Checking status  1.
'       11:59:57.976 Checking status  2.
'       11:59:58.476 Checking status  3.
'       11:59:58.977 Checking status  4.
'       11:59:59.477 Checking status  5.
'       11:59:59.977 Checking status  6.
'       12:00:00.478 Checking status  7.
'       12:00:00.980 Checking status  8.
'       12:00:01.481 Checking status  9.
'       12:00:01.981 Checking status 10.
'       
'       Destroying timer.

注解

回调方法在经过后 dueTime 调用一次，之后每次调用由 period 已用指定的时间间隔。

如果 dueTime 为零 (0) ，则立即调用回调方法。如果 dueTime 为 Timeout.Infinite，则永远不会调用回调方法;计时器已禁用，但可以通过调用 Change 并为指定正值 dueTime来重新启用。

如果 period 为零 (0) 或 Timeout.Infinite，并且 dueTime 不是 Timeout.Infinite，则调用回调方法一次;计时器的定期行为被禁用，但可以通过调用 Change 并为指定正值来 period重新启用。

Change可以从委托调用 TimerCallback 方法。

另请参阅

计时器

适用于

Change(Int64, Int64)

Source:: Timer.cs

Source:: Timer.cs

Source:: Timer.cs

更改计时器的启动时间和方法调用之间的间隔，用 64 位有符号整数度量时间间隔。

public:
 bool Change(long dueTime, long period);

public bool Change (long dueTime, long period);

member this.Change : int64 * int64 -> bool

Public Function Change (dueTime As Long, period As Long) As Boolean

参数

dueTime: Int64

在调用构造 Timer 时指定的回调方法之前的延迟时间量（以毫秒为单位）。指定 Infinite 可防止重新启动计时器。指定零 (0) 可立即重新启动计时器。此值必须小于或等于 4294967294。

period: Int64

调用构造 Timer 时指定的回调方法的时间间隔（以毫秒为单位）。指定 Infinite 可以禁用定期终止。

Boolean

如果计时器更新成功，则为 true；否则为 false。

例外

ObjectDisposedException

Timer 已被释放。

ArgumentOutOfRangeException

dueTime 或 period 小于 -1。

或

dueTime 或 period 大于 4294967294。

注解

回调方法在经过后 dueTime 调用一次，之后每次调用由 period 已用指定的时间间隔。

Change可以从委托调用 TimerCallback 方法。

另请参阅

计时器

适用于

Change(TimeSpan, TimeSpan)

Source:: Timer.cs

Source:: Timer.cs

Source:: Timer.cs

更改计时器的启动时间和方法调用之间的时间间隔，使用 TimeSpan 值度量时间间隔。

public:
 bool Change(TimeSpan dueTime, TimeSpan period);

public:
 virtual bool Change(TimeSpan dueTime, TimeSpan period);

public bool Change (TimeSpan dueTime, TimeSpan period);

member this.Change : TimeSpan * TimeSpan -> bool

abstract member Change : TimeSpan * TimeSpan -> bool
override this.Change : TimeSpan * TimeSpan -> bool

Public Function Change (dueTime As TimeSpan, period As TimeSpan) As Boolean

参数

dueTime: TimeSpan

一个 TimeSpan，表示在调用构造 Timer 时指定的回调方法之前的延迟时间量。指定 InfiniteTimeSpan 可防止重新启动计时器。指定 Zero 可立即重新启动计时器。

period: TimeSpan

在构造 Timer 时指定的回调方法调用之间的时间间隔。指定 InfiniteTimeSpan 可以禁用定期终止。

Boolean

如果计时器更新成功，则为 true；否则为 false。

实现

Change(TimeSpan, TimeSpan)

例外

ObjectDisposedException

Timer 已被释放。

ArgumentOutOfRangeException

dueTime 或 period 参数（单位为毫秒）小于 -1。

NotSupportedException

dueTime 或 period 参数（单位为毫秒）大于 4294967294。

示例

下面的代码示例演示如何启动， Timer 并在一定数量的调用后更改其周期。

using namespace System;
using namespace System::Threading;
ref class StatusChecker
{
private:
   int invokeCount;
   int maxCount;

public:
   StatusChecker( int count )
      : invokeCount( 0 ), maxCount( count )
   {}


   // This method is called by the timer delegate.
   void CheckStatus( Object^ stateInfo )
   {
      AutoResetEvent^ autoEvent = dynamic_cast<AutoResetEvent^>(stateInfo);
      Console::WriteLine( "{0} Checking status {1,2}.", DateTime::Now.ToString(  "h:mm:ss.fff" ), (++invokeCount).ToString() );
      if ( invokeCount == maxCount )
      {
         
         // Reset the counter and signal main.
         invokeCount = 0;
         autoEvent->Set();
      }
   }

};

int main()
{
   AutoResetEvent^ autoEvent = gcnew AutoResetEvent( false );
   StatusChecker^ statusChecker = gcnew StatusChecker( 10 );
   
   // Create the delegate that invokes methods for the timer.
   TimerCallback^ timerDelegate = gcnew TimerCallback( statusChecker, &StatusChecker::CheckStatus );
   TimeSpan delayTime = TimeSpan(0,0,1);
   TimeSpan intervalTime = TimeSpan(0,0,0,0,250);
   
   // Create a timer that signals the delegate to invoke CheckStatus 
   // after one second, and every 1/4 second thereafter.
   Console::WriteLine( "{0} Creating timer.\n", DateTime::Now.ToString(  "h:mm:ss.fff" ) );
   Timer^ stateTimer = gcnew Timer( timerDelegate,autoEvent,delayTime,intervalTime );
   
   // When autoEvent signals, change the period to every 1/2 second.
   autoEvent->WaitOne( 5000, false );
   stateTimer->Change( TimeSpan(0), intervalTime + intervalTime );
   Console::WriteLine( "\nChanging period.\n" );
   
   // When autoEvent signals the second time, dispose of the timer.
   autoEvent->WaitOne( 5000, false );
   stateTimer->~Timer();
   Console::WriteLine( "\nDestroying timer." );
}

using System;
using System.Threading;

class TimerExample
{
    static void Main()
    {
        AutoResetEvent autoEvent     = new AutoResetEvent(false);
        StatusChecker  statusChecker = new StatusChecker(10);

        // Create the delegate that invokes methods for the timer.
        TimerCallback timerDelegate = 
            new TimerCallback(statusChecker.CheckStatus);

        TimeSpan delayTime = new TimeSpan(0, 0, 1);
        TimeSpan intervalTime = new TimeSpan(0, 0, 0, 0, 250);

        // Create a timer that signals the delegate to invoke 
        // CheckStatus after one second, and every 1/4 second 
        // thereafter.
        Console.WriteLine("{0} Creating timer.\n", 
            DateTime.Now.ToString("h:mm:ss.fff"));
        Timer stateTimer = new Timer(
            timerDelegate, autoEvent, delayTime, intervalTime);

        // When autoEvent signals, change the period to every 
        // 1/2 second.
        autoEvent.WaitOne(5000, false);
        stateTimer.Change(new TimeSpan(0), 
            intervalTime + intervalTime);
        Console.WriteLine("\nChanging period.\n");

        // When autoEvent signals the second time, dispose of 
        // the timer.
        autoEvent.WaitOne(5000, false);
        stateTimer.Dispose();
        Console.WriteLine("\nDestroying timer.");
    }
}

class StatusChecker
{
    int invokeCount, maxCount;

    public StatusChecker(int count)
    {
        invokeCount  = 0;
        maxCount = count;
    }

    // This method is called by the timer delegate.
    public void CheckStatus(Object stateInfo)
    {
        AutoResetEvent autoEvent = (AutoResetEvent)stateInfo;
        Console.WriteLine("{0} Checking status {1,2}.", 
            DateTime.Now.ToString("h:mm:ss.fff"), 
            (++invokeCount).ToString());

        if(invokeCount == maxCount)
        {
            // Reset the counter and signal Main.
            invokeCount  = 0;
            autoEvent.Set();
        }
    }
}

Imports System.Threading

Public Class TimerExample

    <MTAThread> _
    Shared Sub Main()
    
        Dim autoEvent As New AutoResetEvent(False)
        Dim statusChecker As New StatusChecker(10)

        ' Create the delegate that invokes methods for the timer.
        Dim timerDelegate As TimerCallback = _
            AddressOf statusChecker.CheckStatus

        Dim delayTime As New TimeSpan(0, 0, 1)
        Dim intervalTime As New TimeSpan(0, 0, 0, 0, 250)

        ' Create a timer that signals the delegate to invoke 
        ' CheckStatus after one second, and every 1/4 second 
        ' thereafter.
        Console.WriteLine("{0} Creating timer." & vbCrLf, _
            DateTime.Now.ToString("h:mm:ss.fff"))
        Dim stateTimer As Timer = New Timer( _
            timerDelegate, autoEvent, delayTime, intervalTime)

        ' When autoEvent signals, change the period to every 
        ' 1/2 second.
        autoEvent.WaitOne(5000, False)
        stateTimer.Change( _
            new TimeSpan(0), intervalTime.Add(intervalTime))
        Console.WriteLine(vbCrLf & "Changing period." & vbCrLf)

        ' When autoEvent signals the second time, dispose of 
        ' the timer.
        autoEvent.WaitOne(5000, False)
        stateTimer.Dispose()
        Console.WriteLine(vbCrLf & "Destroying timer.")
    
    End Sub
End Class

Public Class StatusChecker

    Dim invokeCount, maxCount As Integer 

    Sub New(count As Integer)
        invokeCount  = 0
        maxCount = count
    End Sub

    ' This method is called by the timer delegate.
    Sub CheckStatus(stateInfo As Object)
        Dim autoEvent As AutoResetEvent = _
            DirectCast(stateInfo, AutoResetEvent)
        invokeCount += 1
        Console.WriteLine("{0} Checking status {1,2}.", _
            DateTime.Now.ToString("h:mm:ss.fff"), _
            invokeCount.ToString())

        If invokeCount = maxCount Then
        
            ' Reset the counter and signal to stop the timer.
            invokeCount  = 0
            autoEvent.Set()
        End If
    End Sub

End Class

注解

回调方法在经过后 dueTime 调用一次，之后每次调用由 period 已用指定的时间间隔。

如果 dueTime 为 TimeSpan.Zero，则立即调用回调方法。如果 dueTime 为 InfiniteTimeSpan，则永远不会调用回调方法;计时器已禁用，但可以通过调用 Change 并为指定正值 dueTime来重新启用。

如果 period 为 TimeSpan.Zero 或 InfiniteTimeSpan，并且 dueTime 为正数，则调用回调方法一次;计时器的定期行为被禁用，但可以通过调用 Change 并指定大于零的值来 period重新启用。

Change可以从委托调用 TimerCallback 方法。

另请参阅

计时器

适用于

Change(UInt32, UInt32)

Source:: Timer.cs

Source:: Timer.cs

Source:: Timer.cs

重要

此 API 不符合 CLS。

更改计时器的启动时间和方法调用之间的间隔，用 32 位无符号整数度量时间间隔。

public:
 bool Change(System::UInt32 dueTime, System::UInt32 period);

[System.CLSCompliant(false)]
public bool Change (uint dueTime, uint period);

[<System.CLSCompliant(false)>]
member this.Change : uint32 * uint32 -> bool

Public Function Change (dueTime As UInteger, period As UInteger) As Boolean

参数

dueTime: UInt32

在调用构造 Timer 时指定的回调方法之前的延迟时间量（以毫秒为单位）。指定 Infinite 可防止重新启动计时器。指定零 (0) 可立即重新启动计时器。

period: UInt32

调用构造 Timer 时指定的回调方法的时间间隔（以毫秒为单位）。指定 Infinite 可以禁用定期终止。

Boolean

如果计时器更新成功，则为 true；否则为 false。

属性: CLSCompliantAttribute

例外

ObjectDisposedException

Timer 已被释放。

注解

回调方法在经过后 dueTime 调用一次，之后每次调用由 period 已用指定的时间间隔。

Change可以从委托调用 TimerCallback 方法。

另请参阅

计时器

适用于

通过

Timer.Change 方法

定义

重载

Change(Int32, Int32)

参数

返回

例外

示例

注解

另请参阅

适用于

Change(Int64, Int64)

参数

返回

例外

注解

另请参阅

适用于

Change(TimeSpan, TimeSpan)

参数

返回

实现

例外

示例

注解

另请参阅

适用于

Change(UInt32, UInt32)

参数

返回

例外

注解

另请参阅

适用于

其他资源