Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / ndp / clr / src / BCL / System / Threading / Timer.cs / 2 / Timer.cs
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
/*==============================================================================
**
** Class: TimerQueue
**
**
** Purpose: Class for creating and managing a threadpool
**
**
=============================================================================*/
namespace System.Threading {
using System.Threading;
using System;
using System.Security;
using System.Security.Permissions;
using Microsoft.Win32;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.ConstrainedExecution;
internal class _TimerCallback
{
TimerCallback _timerCallback;
ExecutionContext _executionContext;
Object _state;
static internal ContextCallback _ccb = new ContextCallback(TimerCallback_Context);
static internal void TimerCallback_Context(Object state)
{
_TimerCallback helper = (_TimerCallback) state;
helper._timerCallback(helper._state);
}
internal _TimerCallback(TimerCallback timerCallback, Object state, ref StackCrawlMark stackMark)
{
_timerCallback = timerCallback;
_state = state;
if (!ExecutionContext.IsFlowSuppressed())
{
_executionContext = ExecutionContext.Capture(ref stackMark);
ExecutionContext.ClearSyncContext(_executionContext);
}
}
// call back helper
static internal void PerformTimerCallback(Object state)
{
_TimerCallback helper = (_TimerCallback)state;
BCLDebug.Assert(helper != null, "Null state passed to PerformTimerCallback!");
// call directly if EC flow is suppressed
if (helper._executionContext == null)
{
TimerCallback callback = helper._timerCallback;
callback(helper._state);
}
else
{
// From this point on we can use useExecutionContext for this callback
ExecutionContext.Run(helper._executionContext.CreateCopy(), _ccb, helper);
}
}
}
[System.Runtime.InteropServices.ComVisible(true)]
public delegate void TimerCallback(Object state);
[HostProtection(Synchronization=true, ExternalThreading=true)]
internal sealed class TimerBase : CriticalFinalizerObject, IDisposable
{
#pragma warning disable 169
private IntPtr timerHandle;
private IntPtr delegateInfo;
#pragma warning restore 169
private int timerDeleted;
private int m_lock = 0;
~TimerBase()
{
// lock(this) cannot be used reliably in Cer since thin lock could be
// promoted to syncblock and that is not a guaranteed operation
bool bLockTaken = false;
do
{
if (Interlocked.CompareExchange(ref m_lock, 1, 0) == 0)
{
bLockTaken = true;
try
{
DeleteTimerNative(null);
}
finally
{
m_lock = 0;
}
}
Thread.SpinWait(1); // yield to processor
}
while (!bLockTaken);
}
internal void AddTimer(TimerCallback callback,
Object state,
UInt32 dueTime,
UInt32 period,
ref StackCrawlMark stackMark
)
{
if (callback != null)
{
_TimerCallback callbackHelper = new _TimerCallback(callback, state, ref stackMark);
state = (Object)callbackHelper;
AddTimerNative(state, dueTime, period, ref stackMark);
timerDeleted = 0;
}
else
{
throw new ArgumentNullException("TimerCallback");
}
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
internal bool ChangeTimer(UInt32 dueTime,UInt32 period)
{
bool status = false;
bool bLockTaken = false;
// prepare here to prevent threadabort from occuring which could
// destroy m_lock state. lock(this) can't be used due to critical
// finalizer and thinlock/syncblock escalation.
RuntimeHelpers.PrepareConstrainedRegions();
try
{
}
finally
{
do
{
if (Interlocked.CompareExchange(ref m_lock, 1, 0) == 0)
{
bLockTaken = true;
try
{
if (timerDeleted != 0)
throw new ObjectDisposedException(null, Environment.GetResourceString("ObjectDisposed_Generic"));
status = ChangeTimerNative(dueTime,period);
}
finally
{
m_lock = 0;
}
}
Thread.SpinWait(1); // yield to processor
}
while (!bLockTaken);
}
return status;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
internal bool Dispose(WaitHandle notifyObject)
{
bool status = false;
bool bLockTaken = false;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
}
finally
{
do
{
if (Interlocked.CompareExchange(ref m_lock, 1, 0) == 0)
{
bLockTaken = true;
try
{
status = DeleteTimerNative(notifyObject.SafeWaitHandle);
}
finally
{
m_lock = 0;
}
}
Thread.SpinWait(1); // yield to processor
}
while (!bLockTaken);
GC.SuppressFinalize(this);
}
return status;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
public void Dispose()
{
bool bLockTaken = false;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
}
finally
{
do
{
if (Interlocked.CompareExchange(ref m_lock, 1, 0) == 0)
{
bLockTaken = true;
try
{
DeleteTimerNative(null);
}
finally
{
m_lock = 0;
}
}
Thread.SpinWait(1); // yield to processor
}
while (!bLockTaken);
GC.SuppressFinalize(this);
}
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private extern void AddTimerNative(Object state,
UInt32 dueTime,
UInt32 period,
ref StackCrawlMark stackMark
);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private extern bool ChangeTimerNative(UInt32 dueTime,UInt32 period);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private extern bool DeleteTimerNative(SafeHandle notifyObject);
}
[HostProtection(Synchronization=true, ExternalThreading=true)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Timer : MarshalByRefObject, IDisposable
{
private const UInt32 MAX_SUPPORTED_TIMEOUT = (uint)0xfffffffe;
private TimerBase timerBase;
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public Timer(TimerCallback callback,
Object state,
int dueTime,
int period)
{
if (dueTime < -1)
throw new ArgumentOutOfRangeException("dueTime", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
if (period < -1 )
throw new ArgumentOutOfRangeException("period", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
TimerSetup(callback,state,(UInt32)dueTime,(UInt32)period,ref stackMark);
}
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public Timer(TimerCallback callback,
Object state,
TimeSpan dueTime,
TimeSpan period)
{
long dueTm = (long)dueTime.TotalMilliseconds;
if (dueTm < -1)
throw new ArgumentOutOfRangeException("dueTm",Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
if (dueTm > MAX_SUPPORTED_TIMEOUT)
throw new ArgumentOutOfRangeException("dueTm",Environment.GetResourceString("ArgumentOutOfRange_TimeoutTooLarge"));
long periodTm = (long)period.TotalMilliseconds;
if (periodTm < -1)
throw new ArgumentOutOfRangeException("periodTm",Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
if (periodTm > MAX_SUPPORTED_TIMEOUT)
throw new ArgumentOutOfRangeException("periodTm",Environment.GetResourceString("ArgumentOutOfRange_PeriodTooLarge"));
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
TimerSetup(callback,state,(UInt32)dueTm,(UInt32)periodTm,ref stackMark);
}
[CLSCompliant(false)]
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public Timer(TimerCallback callback,
Object state,
UInt32 dueTime,
UInt32 period)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
TimerSetup(callback,state,dueTime,period,ref stackMark);
}
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public Timer(TimerCallback callback,
Object state,
long dueTime,
long period)
{
if (dueTime < -1)
throw new ArgumentOutOfRangeException("dueTime",Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
if (period < -1)
throw new ArgumentOutOfRangeException("period",Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
if (dueTime > MAX_SUPPORTED_TIMEOUT)
throw new ArgumentOutOfRangeException("dueTime",Environment.GetResourceString("ArgumentOutOfRange_TimeoutTooLarge"));
if (period > MAX_SUPPORTED_TIMEOUT)
throw new ArgumentOutOfRangeException("period",Environment.GetResourceString("ArgumentOutOfRange_PeriodTooLarge"));
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
TimerSetup(callback,state,(UInt32) dueTime, (UInt32) period,ref stackMark);
}
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public Timer(TimerCallback callback)
{
int dueTime = -1; // we want timer to be registered, but not activated. Requires caller to call
int period = -1; // Change after a timer instance is created. This is to avoid the potential
// for a timer to be fired before the returned value is assigned to the variable,
// potentially causing the callback to reference a bogus value (if passing the timer to the callback).
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
TimerSetup(callback, this, (UInt32)dueTime, (UInt32)period, ref stackMark);
}
private void TimerSetup(TimerCallback callback,
Object state,
UInt32 dueTime,
UInt32 period,
ref StackCrawlMark stackMark
)
{
timerBase = new TimerBase();
timerBase.AddTimer(callback, state,(UInt32) dueTime, (UInt32) period, ref stackMark);
}
public bool Change(int dueTime, int period)
{
if (dueTime < -1 )
throw new ArgumentOutOfRangeException("dueTime",Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
if (period < -1)
throw new ArgumentOutOfRangeException("period",Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
return timerBase.ChangeTimer((UInt32)dueTime,(UInt32)period);
}
public bool Change(TimeSpan dueTime, TimeSpan period)
{
return Change((long) dueTime.TotalMilliseconds, (long) period.TotalMilliseconds);
}
[CLSCompliant(false)]
public bool Change(UInt32 dueTime, UInt32 period)
{
return timerBase.ChangeTimer(dueTime,period);
}
public bool Change(long dueTime, long period)
{
if (dueTime < -1 )
throw new ArgumentOutOfRangeException("dueTime", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
if (period < -1)
throw new ArgumentOutOfRangeException("period", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
if (dueTime > MAX_SUPPORTED_TIMEOUT)
throw new ArgumentOutOfRangeException("dueTime", Environment.GetResourceString("ArgumentOutOfRange_TimeoutTooLarge"));
if (period > MAX_SUPPORTED_TIMEOUT)
throw new ArgumentOutOfRangeException("period", Environment.GetResourceString("ArgumentOutOfRange_PeriodTooLarge"));
return timerBase.ChangeTimer((UInt32)dueTime,(UInt32)period);
}
public bool Dispose(WaitHandle notifyObject)
{
if (notifyObject==null)
throw new ArgumentNullException("notifyObject");
return timerBase.Dispose(notifyObject);
}
public void Dispose()
{
timerBase.Dispose();
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
/*==============================================================================
**
** Class: TimerQueue
**
**
** Purpose: Class for creating and managing a threadpool
**
**
=============================================================================*/
namespace System.Threading {
using System.Threading;
using System;
using System.Security;
using System.Security.Permissions;
using Microsoft.Win32;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.ConstrainedExecution;
internal class _TimerCallback
{
TimerCallback _timerCallback;
ExecutionContext _executionContext;
Object _state;
static internal ContextCallback _ccb = new ContextCallback(TimerCallback_Context);
static internal void TimerCallback_Context(Object state)
{
_TimerCallback helper = (_TimerCallback) state;
helper._timerCallback(helper._state);
}
internal _TimerCallback(TimerCallback timerCallback, Object state, ref StackCrawlMark stackMark)
{
_timerCallback = timerCallback;
_state = state;
if (!ExecutionContext.IsFlowSuppressed())
{
_executionContext = ExecutionContext.Capture(ref stackMark);
ExecutionContext.ClearSyncContext(_executionContext);
}
}
// call back helper
static internal void PerformTimerCallback(Object state)
{
_TimerCallback helper = (_TimerCallback)state;
BCLDebug.Assert(helper != null, "Null state passed to PerformTimerCallback!");
// call directly if EC flow is suppressed
if (helper._executionContext == null)
{
TimerCallback callback = helper._timerCallback;
callback(helper._state);
}
else
{
// From this point on we can use useExecutionContext for this callback
ExecutionContext.Run(helper._executionContext.CreateCopy(), _ccb, helper);
}
}
}
[System.Runtime.InteropServices.ComVisible(true)]
public delegate void TimerCallback(Object state);
[HostProtection(Synchronization=true, ExternalThreading=true)]
internal sealed class TimerBase : CriticalFinalizerObject, IDisposable
{
#pragma warning disable 169
private IntPtr timerHandle;
private IntPtr delegateInfo;
#pragma warning restore 169
private int timerDeleted;
private int m_lock = 0;
~TimerBase()
{
// lock(this) cannot be used reliably in Cer since thin lock could be
// promoted to syncblock and that is not a guaranteed operation
bool bLockTaken = false;
do
{
if (Interlocked.CompareExchange(ref m_lock, 1, 0) == 0)
{
bLockTaken = true;
try
{
DeleteTimerNative(null);
}
finally
{
m_lock = 0;
}
}
Thread.SpinWait(1); // yield to processor
}
while (!bLockTaken);
}
internal void AddTimer(TimerCallback callback,
Object state,
UInt32 dueTime,
UInt32 period,
ref StackCrawlMark stackMark
)
{
if (callback != null)
{
_TimerCallback callbackHelper = new _TimerCallback(callback, state, ref stackMark);
state = (Object)callbackHelper;
AddTimerNative(state, dueTime, period, ref stackMark);
timerDeleted = 0;
}
else
{
throw new ArgumentNullException("TimerCallback");
}
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
internal bool ChangeTimer(UInt32 dueTime,UInt32 period)
{
bool status = false;
bool bLockTaken = false;
// prepare here to prevent threadabort from occuring which could
// destroy m_lock state. lock(this) can't be used due to critical
// finalizer and thinlock/syncblock escalation.
RuntimeHelpers.PrepareConstrainedRegions();
try
{
}
finally
{
do
{
if (Interlocked.CompareExchange(ref m_lock, 1, 0) == 0)
{
bLockTaken = true;
try
{
if (timerDeleted != 0)
throw new ObjectDisposedException(null, Environment.GetResourceString("ObjectDisposed_Generic"));
status = ChangeTimerNative(dueTime,period);
}
finally
{
m_lock = 0;
}
}
Thread.SpinWait(1); // yield to processor
}
while (!bLockTaken);
}
return status;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
internal bool Dispose(WaitHandle notifyObject)
{
bool status = false;
bool bLockTaken = false;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
}
finally
{
do
{
if (Interlocked.CompareExchange(ref m_lock, 1, 0) == 0)
{
bLockTaken = true;
try
{
status = DeleteTimerNative(notifyObject.SafeWaitHandle);
}
finally
{
m_lock = 0;
}
}
Thread.SpinWait(1); // yield to processor
}
while (!bLockTaken);
GC.SuppressFinalize(this);
}
return status;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
public void Dispose()
{
bool bLockTaken = false;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
}
finally
{
do
{
if (Interlocked.CompareExchange(ref m_lock, 1, 0) == 0)
{
bLockTaken = true;
try
{
DeleteTimerNative(null);
}
finally
{
m_lock = 0;
}
}
Thread.SpinWait(1); // yield to processor
}
while (!bLockTaken);
GC.SuppressFinalize(this);
}
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private extern void AddTimerNative(Object state,
UInt32 dueTime,
UInt32 period,
ref StackCrawlMark stackMark
);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private extern bool ChangeTimerNative(UInt32 dueTime,UInt32 period);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private extern bool DeleteTimerNative(SafeHandle notifyObject);
}
[HostProtection(Synchronization=true, ExternalThreading=true)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Timer : MarshalByRefObject, IDisposable
{
private const UInt32 MAX_SUPPORTED_TIMEOUT = (uint)0xfffffffe;
private TimerBase timerBase;
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public Timer(TimerCallback callback,
Object state,
int dueTime,
int period)
{
if (dueTime < -1)
throw new ArgumentOutOfRangeException("dueTime", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
if (period < -1 )
throw new ArgumentOutOfRangeException("period", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
TimerSetup(callback,state,(UInt32)dueTime,(UInt32)period,ref stackMark);
}
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public Timer(TimerCallback callback,
Object state,
TimeSpan dueTime,
TimeSpan period)
{
long dueTm = (long)dueTime.TotalMilliseconds;
if (dueTm < -1)
throw new ArgumentOutOfRangeException("dueTm",Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
if (dueTm > MAX_SUPPORTED_TIMEOUT)
throw new ArgumentOutOfRangeException("dueTm",Environment.GetResourceString("ArgumentOutOfRange_TimeoutTooLarge"));
long periodTm = (long)period.TotalMilliseconds;
if (periodTm < -1)
throw new ArgumentOutOfRangeException("periodTm",Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
if (periodTm > MAX_SUPPORTED_TIMEOUT)
throw new ArgumentOutOfRangeException("periodTm",Environment.GetResourceString("ArgumentOutOfRange_PeriodTooLarge"));
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
TimerSetup(callback,state,(UInt32)dueTm,(UInt32)periodTm,ref stackMark);
}
[CLSCompliant(false)]
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public Timer(TimerCallback callback,
Object state,
UInt32 dueTime,
UInt32 period)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
TimerSetup(callback,state,dueTime,period,ref stackMark);
}
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public Timer(TimerCallback callback,
Object state,
long dueTime,
long period)
{
if (dueTime < -1)
throw new ArgumentOutOfRangeException("dueTime",Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
if (period < -1)
throw new ArgumentOutOfRangeException("period",Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
if (dueTime > MAX_SUPPORTED_TIMEOUT)
throw new ArgumentOutOfRangeException("dueTime",Environment.GetResourceString("ArgumentOutOfRange_TimeoutTooLarge"));
if (period > MAX_SUPPORTED_TIMEOUT)
throw new ArgumentOutOfRangeException("period",Environment.GetResourceString("ArgumentOutOfRange_PeriodTooLarge"));
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
TimerSetup(callback,state,(UInt32) dueTime, (UInt32) period,ref stackMark);
}
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public Timer(TimerCallback callback)
{
int dueTime = -1; // we want timer to be registered, but not activated. Requires caller to call
int period = -1; // Change after a timer instance is created. This is to avoid the potential
// for a timer to be fired before the returned value is assigned to the variable,
// potentially causing the callback to reference a bogus value (if passing the timer to the callback).
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
TimerSetup(callback, this, (UInt32)dueTime, (UInt32)period, ref stackMark);
}
private void TimerSetup(TimerCallback callback,
Object state,
UInt32 dueTime,
UInt32 period,
ref StackCrawlMark stackMark
)
{
timerBase = new TimerBase();
timerBase.AddTimer(callback, state,(UInt32) dueTime, (UInt32) period, ref stackMark);
}
public bool Change(int dueTime, int period)
{
if (dueTime < -1 )
throw new ArgumentOutOfRangeException("dueTime",Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
if (period < -1)
throw new ArgumentOutOfRangeException("period",Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
return timerBase.ChangeTimer((UInt32)dueTime,(UInt32)period);
}
public bool Change(TimeSpan dueTime, TimeSpan period)
{
return Change((long) dueTime.TotalMilliseconds, (long) period.TotalMilliseconds);
}
[CLSCompliant(false)]
public bool Change(UInt32 dueTime, UInt32 period)
{
return timerBase.ChangeTimer(dueTime,period);
}
public bool Change(long dueTime, long period)
{
if (dueTime < -1 )
throw new ArgumentOutOfRangeException("dueTime", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
if (period < -1)
throw new ArgumentOutOfRangeException("period", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1"));
if (dueTime > MAX_SUPPORTED_TIMEOUT)
throw new ArgumentOutOfRangeException("dueTime", Environment.GetResourceString("ArgumentOutOfRange_TimeoutTooLarge"));
if (period > MAX_SUPPORTED_TIMEOUT)
throw new ArgumentOutOfRangeException("period", Environment.GetResourceString("ArgumentOutOfRange_PeriodTooLarge"));
return timerBase.ChangeTimer((UInt32)dueTime,(UInt32)period);
}
public bool Dispose(WaitHandle notifyObject)
{
if (notifyObject==null)
throw new ArgumentNullException("notifyObject");
return timerBase.Dispose(notifyObject);
}
public void Dispose()
{
timerBase.Dispose();
}
}
}
// 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
- ResourcePool.cs
- TextDocumentView.cs
- ReadOnlyDataSource.cs
- QueryStringConverter.cs
- InvokeAction.cs
- DesignerWebPartChrome.cs
- BindingSource.cs
- TextDecorationLocationValidation.cs
- SecurityKeyType.cs
- StylusPointPropertyUnit.cs
- HttpCacheParams.cs
- ExceptionHandlerDesigner.cs
- XPathMultyIterator.cs
- SecureUICommand.cs
- WindowsStartMenu.cs
- ActivityPreviewDesigner.cs
- ProjectionCamera.cs
- InfocardChannelParameter.cs
- StateChangeEvent.cs
- Item.cs
- Literal.cs
- TrustManager.cs
- QueryCoreOp.cs
- BuildProviderAppliesToAttribute.cs
- FileVersionInfo.cs
- SchemaCompiler.cs
- InfoCardRSAPKCS1SignatureDeformatter.cs
- NextPreviousPagerField.cs
- ReturnType.cs
- XmlRawWriter.cs
- XmlAggregates.cs
- Column.cs
- Converter.cs
- OnOperation.cs
- TextDecorationCollection.cs
- IListConverters.cs
- ProtectedProviderSettings.cs
- SocketInformation.cs
- NameObjectCollectionBase.cs
- DurableInstance.cs
- WindowsFormsHost.cs
- SupportingTokenListenerFactory.cs
- Subtree.cs
- EndpointConfigContainer.cs
- ObjectKeyFrameCollection.cs
- CancelEventArgs.cs
- BaseDataBoundControl.cs
- InkCanvasAutomationPeer.cs
- ViewLoader.cs
- CallSiteHelpers.cs
- UnsafeNativeMethods.cs
- DbException.cs
- SizeValueSerializer.cs
- SessionStateUtil.cs
- RelationshipWrapper.cs
- PathTooLongException.cs
- ScriptBehaviorDescriptor.cs
- SerializationSectionGroup.cs
- BitmapEffectGeneralTransform.cs
- UnsafeNativeMethodsMilCoreApi.cs
- Baml2006ReaderContext.cs
- ConfigurationFileMap.cs
- ExpressionCopier.cs
- ADMembershipProvider.cs
- OleDbInfoMessageEvent.cs
- RootContext.cs
- TraceSource.cs
- Dictionary.cs
- regiisutil.cs
- DataGridViewCellCollection.cs
- ELinqQueryState.cs
- TextTreeNode.cs
- ChildTable.cs
- ByteBufferPool.cs
- FastEncoderWindow.cs
- EditCommandColumn.cs
- Scheduling.cs
- BindingMAnagerBase.cs
- SettingsSavedEventArgs.cs
- MarkupObject.cs
- Matrix3D.cs
- DataGridViewCellMouseEventArgs.cs
- ScrollChangedEventArgs.cs
- PartialCachingControl.cs
- XPathEmptyIterator.cs
- SafeRegistryHandle.cs
- ManagedWndProcTracker.cs
- ComponentDesigner.cs
- Configuration.cs
- MarkupProperty.cs
- TaskbarItemInfo.cs
- CompositeControl.cs
- InOutArgument.cs
- Ray3DHitTestResult.cs
- BrowserCapabilitiesCodeGenerator.cs
- XmlNamespaceDeclarationsAttribute.cs
- ByteAnimationBase.cs
- MatchSingleFxEngineOpcode.cs
- ClientSettingsProvider.cs
- PolicyException.cs