Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / ndp / fx / src / Services / Timers / System / Timers / Timer.cs / 1 / Timer.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Timers {
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using System.ComponentModel;
using System.ComponentModel.Design;
using System;
using Microsoft.Win32;
using Microsoft.Win32.SafeHandles;
///
/// Handles recurring events in an application.
///
[
DefaultProperty("Interval"),
DefaultEvent("Elapsed"),
HostProtection(Synchronization=true, ExternalThreading=true)
]
public class Timer : Component, ISupportInitialize {
private double interval;
private bool enabled;
private bool initializing;
private bool delayedEnable;
private ElapsedEventHandler onIntervalElapsed;
private bool autoReset;
private ISynchronizeInvoke synchronizingObject;
private bool disposed;
private System.Threading.Timer timer;
private TimerCallback callback;
private Object cookie;
///
/// Initializes a new instance of the class, with the properties
/// set to initial values.
///
public Timer()
: base() {
interval = 100;
enabled = false;
autoReset = true;
initializing = false;
delayedEnable = false;
callback = new TimerCallback(this.MyTimerCallback);
}
///
///
/// Initializes a new instance of the class, setting the property to the specified period.
///
///
public Timer(double interval)
: this() {
if (interval <= 0)
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "interval", interval));
int i = (int)Math.Ceiling(interval);
if( i < 0) {
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "interval", interval));
}
this.interval = interval;
}
///
/// Gets or sets a value indicating whether the Timer raises the Tick event each time the specified
/// Interval has elapsed,
/// when Enabled is set to true.
///
[Category("Behavior"), TimersDescription(SR.TimerAutoReset), DefaultValue(true)]
public bool AutoReset {
get {
return this.autoReset;
}
set {
if (DesignMode)
this.autoReset = value;
else if (this.autoReset != value) {
this.autoReset = value;
if( timer != null) {
UpdateTimer();
}
}
}
}
///
/// Gets or sets a value indicating whether the
/// is able
/// to raise events at a defined interval.
///
//[....] - The default value by design is false, don't change it.
[Category("Behavior"), TimersDescription(SR.TimerEnabled), DefaultValue(false)]
public bool Enabled {
get {
return this.enabled;
}
set {
if (DesignMode) {
this.delayedEnable = value;
this.enabled = value;
}
else if (initializing)
this.delayedEnable = value;
else if (enabled != value) {
if (!value) {
if( timer != null) {
cookie = null;
timer.Dispose();
timer = null;
}
enabled = value;
}
else {
enabled = value;
if( timer == null) {
if (disposed) {
throw new ObjectDisposedException(GetType().Name);
}
int i = (int)Math.Ceiling(interval);
cookie = new Object();
timer = new System.Threading.Timer(callback, cookie, i, autoReset? i:Timeout.Infinite);
}
else {
UpdateTimer();
}
}
}
}
}
private void UpdateTimer() {
int i = (int)Math.Ceiling(interval);
timer.Change(i, autoReset? i :Timeout.Infinite );
}
///
/// Gets or
/// sets the interval on which
/// to raise events.
///
[Category("Behavior"), TimersDescription(SR.TimerInterval), DefaultValue(100d), RecommendedAsConfigurable(true)]
public double Interval {
get {
return this.interval;
}
set {
if (value <= 0)
throw new ArgumentException(SR.GetString(SR.TimerInvalidInterval, value, 0));
interval = value;
if (timer != null) {
UpdateTimer();
}
}
}
///
/// Occurs when the has
/// elapsed.
///
[Category("Behavior"), TimersDescription(SR.TimerIntervalElapsed)]
public event ElapsedEventHandler Elapsed {
add {
onIntervalElapsed += value;
}
remove {
onIntervalElapsed -= value;
}
}
///
///
/// Sets the enable property in design mode to true by default.
///
///
///
public override ISite Site {
set {
base.Site = value;
if (this.DesignMode)
this.enabled= true;
}
get {
return base.Site;
}
}
///
/// Gets or sets the object used to marshal event-handler calls that are issued when
/// an interval has elapsed.
///
[
Browsable(false),
DefaultValue(null),
TimersDescription(SR.TimerSynchronizingObject)
]
public ISynchronizeInvoke SynchronizingObject {
get {
if (this.synchronizingObject == null && DesignMode) {
IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));
if (host != null) {
object baseComponent = host.RootComponent;
if (baseComponent != null && baseComponent is ISynchronizeInvoke)
this.synchronizingObject = (ISynchronizeInvoke)baseComponent;
}
}
return this.synchronizingObject;
}
set {
this.synchronizingObject = value;
}
}
///
///
/// Notifies
/// the object that initialization is beginning and tells it to stand by.
///
///
public void BeginInit() {
this.Close();
this.initializing = true;
}
///
/// Disposes of the resources (other than memory) used by
/// the .
///
public void Close() {
initializing = false;
delayedEnable = false;
enabled = false;
if (timer != null ) {
timer.Dispose();
timer = null;
}
}
///
///
///
protected override void Dispose(bool disposing) {
Close();
this.disposed = true;
base.Dispose(disposing);
}
///
///
/// Notifies the object that initialization is complete.
///
///
public void EndInit() {
this.initializing = false;
this.Enabled = this.delayedEnable;
}
///
/// Starts the timing by setting to .
///
public void Start() {
Enabled = true;
}
///
///
/// Stops the timing by setting to .
///
///
public void Stop() {
Enabled = false;
}
private void MyTimerCallback(object state) {
// System.Threading.Timer will not cancel the work item queued before the timer is stopped.
// We don't want to handle the callback after a timer is stopped.
if( state != cookie) {
return;
}
if (!this.autoReset) {
enabled = false;
}
FILE_TIME filetime = new FILE_TIME();
GetSystemTimeAsFileTime(ref filetime);
ElapsedEventArgs elapsedEventArgs = new ElapsedEventArgs(filetime.ftTimeLow, filetime.ftTimeHigh);
try {
// To avoid ---- between remove handler and raising the event
ElapsedEventHandler intervalElapsed = this.onIntervalElapsed;
if (intervalElapsed != null) {
if (this.SynchronizingObject != null && this.SynchronizingObject.InvokeRequired)
this.SynchronizingObject.BeginInvoke(intervalElapsed, new object[]{this, elapsedEventArgs});
else
intervalElapsed(this, elapsedEventArgs);
}
}
catch {
}
}
[StructLayout(LayoutKind.Sequential)]
internal struct FILE_TIME {
internal int ftTimeLow;
internal int ftTimeHigh;
}
[DllImport(ExternDll.Kernel32), SuppressUnmanagedCodeSecurityAttribute()]
internal static extern void GetSystemTimeAsFileTime(ref FILE_TIME lpSystemTimeAsFileTime);
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Timers {
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using System.ComponentModel;
using System.ComponentModel.Design;
using System;
using Microsoft.Win32;
using Microsoft.Win32.SafeHandles;
///
/// Handles recurring events in an application.
///
[
DefaultProperty("Interval"),
DefaultEvent("Elapsed"),
HostProtection(Synchronization=true, ExternalThreading=true)
]
public class Timer : Component, ISupportInitialize {
private double interval;
private bool enabled;
private bool initializing;
private bool delayedEnable;
private ElapsedEventHandler onIntervalElapsed;
private bool autoReset;
private ISynchronizeInvoke synchronizingObject;
private bool disposed;
private System.Threading.Timer timer;
private TimerCallback callback;
private Object cookie;
///
/// Initializes a new instance of the class, with the properties
/// set to initial values.
///
public Timer()
: base() {
interval = 100;
enabled = false;
autoReset = true;
initializing = false;
delayedEnable = false;
callback = new TimerCallback(this.MyTimerCallback);
}
///
///
/// Initializes a new instance of the class, setting the property to the specified period.
///
///
public Timer(double interval)
: this() {
if (interval <= 0)
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "interval", interval));
int i = (int)Math.Ceiling(interval);
if( i < 0) {
throw new ArgumentException(SR.GetString(SR.InvalidParameter, "interval", interval));
}
this.interval = interval;
}
///
/// Gets or sets a value indicating whether the Timer raises the Tick event each time the specified
/// Interval has elapsed,
/// when Enabled is set to true.
///
[Category("Behavior"), TimersDescription(SR.TimerAutoReset), DefaultValue(true)]
public bool AutoReset {
get {
return this.autoReset;
}
set {
if (DesignMode)
this.autoReset = value;
else if (this.autoReset != value) {
this.autoReset = value;
if( timer != null) {
UpdateTimer();
}
}
}
}
///
/// Gets or sets a value indicating whether the
/// is able
/// to raise events at a defined interval.
///
//[....] - The default value by design is false, don't change it.
[Category("Behavior"), TimersDescription(SR.TimerEnabled), DefaultValue(false)]
public bool Enabled {
get {
return this.enabled;
}
set {
if (DesignMode) {
this.delayedEnable = value;
this.enabled = value;
}
else if (initializing)
this.delayedEnable = value;
else if (enabled != value) {
if (!value) {
if( timer != null) {
cookie = null;
timer.Dispose();
timer = null;
}
enabled = value;
}
else {
enabled = value;
if( timer == null) {
if (disposed) {
throw new ObjectDisposedException(GetType().Name);
}
int i = (int)Math.Ceiling(interval);
cookie = new Object();
timer = new System.Threading.Timer(callback, cookie, i, autoReset? i:Timeout.Infinite);
}
else {
UpdateTimer();
}
}
}
}
}
private void UpdateTimer() {
int i = (int)Math.Ceiling(interval);
timer.Change(i, autoReset? i :Timeout.Infinite );
}
///
/// Gets or
/// sets the interval on which
/// to raise events.
///
[Category("Behavior"), TimersDescription(SR.TimerInterval), DefaultValue(100d), RecommendedAsConfigurable(true)]
public double Interval {
get {
return this.interval;
}
set {
if (value <= 0)
throw new ArgumentException(SR.GetString(SR.TimerInvalidInterval, value, 0));
interval = value;
if (timer != null) {
UpdateTimer();
}
}
}
///
/// Occurs when the has
/// elapsed.
///
[Category("Behavior"), TimersDescription(SR.TimerIntervalElapsed)]
public event ElapsedEventHandler Elapsed {
add {
onIntervalElapsed += value;
}
remove {
onIntervalElapsed -= value;
}
}
///
///
/// Sets the enable property in design mode to true by default.
///
///
///
public override ISite Site {
set {
base.Site = value;
if (this.DesignMode)
this.enabled= true;
}
get {
return base.Site;
}
}
///
/// Gets or sets the object used to marshal event-handler calls that are issued when
/// an interval has elapsed.
///
[
Browsable(false),
DefaultValue(null),
TimersDescription(SR.TimerSynchronizingObject)
]
public ISynchronizeInvoke SynchronizingObject {
get {
if (this.synchronizingObject == null && DesignMode) {
IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));
if (host != null) {
object baseComponent = host.RootComponent;
if (baseComponent != null && baseComponent is ISynchronizeInvoke)
this.synchronizingObject = (ISynchronizeInvoke)baseComponent;
}
}
return this.synchronizingObject;
}
set {
this.synchronizingObject = value;
}
}
///
///
/// Notifies
/// the object that initialization is beginning and tells it to stand by.
///
///
public void BeginInit() {
this.Close();
this.initializing = true;
}
///
/// Disposes of the resources (other than memory) used by
/// the .
///
public void Close() {
initializing = false;
delayedEnable = false;
enabled = false;
if (timer != null ) {
timer.Dispose();
timer = null;
}
}
///
///
///
protected override void Dispose(bool disposing) {
Close();
this.disposed = true;
base.Dispose(disposing);
}
///
///
/// Notifies the object that initialization is complete.
///
///
public void EndInit() {
this.initializing = false;
this.Enabled = this.delayedEnable;
}
///
/// Starts the timing by setting to .
///
public void Start() {
Enabled = true;
}
///
///
/// Stops the timing by setting to .
///
///
public void Stop() {
Enabled = false;
}
private void MyTimerCallback(object state) {
// System.Threading.Timer will not cancel the work item queued before the timer is stopped.
// We don't want to handle the callback after a timer is stopped.
if( state != cookie) {
return;
}
if (!this.autoReset) {
enabled = false;
}
FILE_TIME filetime = new FILE_TIME();
GetSystemTimeAsFileTime(ref filetime);
ElapsedEventArgs elapsedEventArgs = new ElapsedEventArgs(filetime.ftTimeLow, filetime.ftTimeHigh);
try {
// To avoid ---- between remove handler and raising the event
ElapsedEventHandler intervalElapsed = this.onIntervalElapsed;
if (intervalElapsed != null) {
if (this.SynchronizingObject != null && this.SynchronizingObject.InvokeRequired)
this.SynchronizingObject.BeginInvoke(intervalElapsed, new object[]{this, elapsedEventArgs});
else
intervalElapsed(this, elapsedEventArgs);
}
}
catch {
}
}
[StructLayout(LayoutKind.Sequential)]
internal struct FILE_TIME {
internal int ftTimeLow;
internal int ftTimeHigh;
}
[DllImport(ExternDll.Kernel32), SuppressUnmanagedCodeSecurityAttribute()]
internal static extern void GetSystemTimeAsFileTime(ref FILE_TIME lpSystemTimeAsFileTime);
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- LambdaCompiler.Statements.cs
- EqualityComparer.cs
- DrawingDrawingContext.cs
- DesignerDataParameter.cs
- NumericUpDownAccelerationCollection.cs
- objectquery_tresulttype.cs
- UnmanagedMarshal.cs
- DataTableNewRowEvent.cs
- ProtocolsConfiguration.cs
- DownloadProgressEventArgs.cs
- WMIGenerator.cs
- ScrollableControlDesigner.cs
- Selection.cs
- TPLETWProvider.cs
- QilVisitor.cs
- Shared.cs
- BasicKeyConstraint.cs
- DocumentSequence.cs
- CodeCastExpression.cs
- PresentationSource.cs
- OdbcConnectionFactory.cs
- CanonicalXml.cs
- XamlHostingSectionGroup.cs
- Effect.cs
- ParseChildrenAsPropertiesAttribute.cs
- WebPartEditorApplyVerb.cs
- ThreadStateException.cs
- DataControlButton.cs
- IndexerNameAttribute.cs
- ThrowHelper.cs
- PriorityBinding.cs
- InteropAutomationProvider.cs
- ControllableStoryboardAction.cs
- COSERVERINFO.cs
- DbReferenceCollection.cs
- DSASignatureDeformatter.cs
- Vector.cs
- AnnotationStore.cs
- ConstantSlot.cs
- HttpChannelListener.cs
- KeyValueConfigurationCollection.cs
- ErrorWebPart.cs
- TypefaceMetricsCache.cs
- wmiutil.cs
- EventLogQuery.cs
- HtmlFormWrapper.cs
- ViewSimplifier.cs
- SoapAttributeAttribute.cs
- bidPrivateBase.cs
- ViewStateModeByIdAttribute.cs
- SingleResultAttribute.cs
- TabControlCancelEvent.cs
- AggregateNode.cs
- GenericWebPart.cs
- DbConnectionPoolCounters.cs
- CacheChildrenQuery.cs
- X509ScopedServiceCertificateElementCollection.cs
- QueryContinueDragEventArgs.cs
- Metafile.cs
- TableLayoutPanelCellPosition.cs
- HttpModuleAction.cs
- RectangleF.cs
- ShaderRenderModeValidation.cs
- SessionParameter.cs
- IconBitmapDecoder.cs
- AutoSizeComboBox.cs
- DesignerDataStoredProcedure.cs
- ExternalCalls.cs
- ButtonBaseAdapter.cs
- TraceEventCache.cs
- Application.cs
- AlternateView.cs
- BuilderInfo.cs
- Exception.cs
- PropertyRecord.cs
- DBSqlParserTable.cs
- PingReply.cs
- UnsafeNativeMethods.cs
- MetadataItem.cs
- ACE.cs
- DocumentViewer.cs
- Sequence.cs
- VersionedStream.cs
- SecurityTokenSpecification.cs
- SerializationAttributes.cs
- SiteMembershipCondition.cs
- EntityProviderFactory.cs
- RecognitionEventArgs.cs
- EpmTargetPathSegment.cs
- ConfigurationSectionGroup.cs
- CryptoHandle.cs
- MailBnfHelper.cs
- PopupEventArgs.cs
- Setter.cs
- keycontainerpermission.cs
- Label.cs
- TokenBasedSet.cs
- XmlCDATASection.cs
- Button.cs
- Visual3D.cs