<?xml version="1.0" encoding="utf-8"?>
<Type Name="Timer" FullName="System.Timers.Timer">
  <TypeSignature Language="C#" Maintainer="auto" Value="public class Timer : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize" />
  <TypeSignature Language="ILAsm" Value=".class public auto ansi beforefieldinit Timer extends System.ComponentModel.Component implements class System.ComponentModel.ISupportInitialize" />
  <AssemblyInfo>
    <AssemblyName>System</AssemblyName>
    <AssemblyPublicKey>[00 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00]</AssemblyPublicKey>
    <AssemblyVersion>1.0.3300.0</AssemblyVersion>
    <AssemblyVersion>1.0.5000.0</AssemblyVersion>
    <AssemblyVersion>2.0.0.0</AssemblyVersion>
    <AssemblyVersion>4.0.0.0</AssemblyVersion>
  </AssemblyInfo>
  <ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the &lt;link location="node:gtk-sharp/programming/threads"&gt;Gtk# Thread Programming&lt;/link&gt; for details.</ThreadSafetyStatement>
  <Base>
    <BaseTypeName>System.ComponentModel.Component</BaseTypeName>
  </Base>
  <Interfaces>
    <Interface>
      <InterfaceName>System.ComponentModel.ISupportInitialize</InterfaceName>
    </Interface>
  </Interfaces>
  <Attributes>
    <Attribute>
      <AttributeName>System.ComponentModel.DefaultEvent("Elapsed")</AttributeName>
    </Attribute>
    <Attribute>
      <AttributeName>System.ComponentModel.DefaultProperty("Interval")</AttributeName>
    </Attribute>
  </Attributes>
  <Docs>
    <remarks>
      <attribution license="cc4" from="Microsoft" modified="false" />
      <para>The <see cref="T:System.Timers.Timer" /> component is a server-based timer, which allows you to specify a recurring interval at which the <see cref="E:System.Timers.Timer.Elapsed" /> event is raised in your application. You can then handle this event to provide regular processing. For example, suppose you have a critical server that must be kept running 24 hours a day, 7 days a week. You could create a service that uses a <see cref="T:System.Timers.Timer" /> to periodically check the server and ensure that the system is up and running. If the system is not responding, the service could attempt to restart the server or notify an administrator.</para>
      <para>The server-based <see cref="T:System.Timers.Timer" /> is designed for use with worker threads in a multithreaded environment. Server timers can move among threads to handle the raised <see cref="E:System.Timers.Timer.Elapsed" /> event, resulting in more accuracy than Windows timers in raising the event on time. </para>
      <para>The <see cref="T:System.Timers.Timer" /> component raises the <see cref="E:System.Timers.Timer.Elapsed" /> event, based on the value of the <see cref="P:System.Timers.Timer.Interval" /> property. You can handle this event to perform the processing you need. For example, suppose that you have an online sales application that continuously posts sales orders to a database. The service that compiles the instructions for shipping operates on a batch of orders rather than processing each order individually. You could use a <see cref="T:System.Timers.Timer" /> to start the batch processing every 30 minutes.</para>
      <block subset="none" type="note">
        <para>When <see cref="P:System.Timers.Timer.AutoReset" /> is set to false, the <see cref="T:System.Timers.Timer" /> raises the <see cref="E:System.Timers.Timer.Elapsed" /> event only once, after the first <see cref="P:System.Timers.Timer.Interval" /> has elapsed. To keep raising the <see cref="E:System.Timers.Timer.Elapsed" /> event on the <see cref="P:System.Timers.Timer.Interval" />, set <see cref="P:System.Timers.Timer.AutoReset" /> to true.</para>
      </block>
      <para>In the .NET Framework version 2.0 and earlier, the <see cref="T:System.Timers.Timer" /> component catches and suppresses all exceptions thrown by event handlers for the <see cref="E:System.Timers.Timer.Elapsed" /> event. This behavior is subject to change in future releases of the .NET Framework.</para>
      <para>If the <see cref="P:System.Timers.Timer.SynchronizingObject" /> property is null, the <see cref="E:System.Timers.Timer.Elapsed" /> event is raised on a <see cref="T:System.Threading.ThreadPool" /> thread. If processing of the <see cref="E:System.Timers.Timer.Elapsed" /> event lasts longer than <see cref="P:System.Timers.Timer.Interval" />, the event might be raised again on another <see cref="T:System.Threading.ThreadPool" /> thread. In this situation, the event handler should be reentrant.</para>
      <block subset="none" type="note">
        <para>The event-handling method might run on one thread at the same time that another thread calls the <see cref="M:System.Timers.Timer.Stop" /> method or sets the <see cref="P:System.Timers.Timer.Enabled" /> property to false. This might result in the <see cref="E:System.Timers.Timer.Elapsed" /> event being raised after the timer is stopped. The example code for the <see cref="M:System.Timers.Timer.Stop" /> method shows one way to avoid this race condition.</para>
      </block>
      <para>Even if <see cref="P:System.Timers.Timer.SynchronizingObject" /> is not null, <see cref="E:System.Timers.Timer.Elapsed" /> events can occur after the <see cref="Overload:System.Timers.Timer.Dispose" /> or <see cref="M:System.Timers.Timer.Stop" /> method has been called or after the <see cref="P:System.Timers.Timer.Enabled" /> property has been set to false, because the signal to raise the <see cref="E:System.Timers.Timer.Elapsed" /> event is always queued for execution on a thread pool thread. One way to resolve this race condition is to set a flag that tells the event handler for the <see cref="E:System.Timers.Timer.Elapsed" /> event to ignore subsequent events. </para>
      <para>If you use the <see cref="T:System.Timers.Timer" /> with a user interface element, such as a form or control, without placing the timer on that user interface element, assign the form or control that contains the <see cref="T:System.Timers.Timer" /> to the <see cref="P:System.Timers.Timer.SynchronizingObject" /> property, so that the event is marshaled to the user interface thread. </para>
      <para>The <see cref="T:System.Timers.Timer" /> is not visible at run time.</para>
      <para>For a list of initial property values for an instance of <see cref="T:System.Timers.Timer" />, see the <see cref="M:System.Timers.Timer.#ctor" /> constructor.</para>
    </remarks>
    <summary>
      <attribution license="cc4" from="Microsoft" modified="false" />
      <para>Generates recurring events in an application.</para>
    </summary>
  </Docs>
  <Members>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public Timer ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor() cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue />
      <Parameters />
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The following table shows initial property values for an instance of <see cref="T:System.Timers.Timer" />.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Property </para>
                </term>
                <description>
                  <para>Initial value </para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>
                  <see cref="P:System.Timers.Timer.AutoReset" /> </para>
              </term>
              <description>
                <para>true </para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="P:System.Timers.Timer.Enabled" /> </para>
              </term>
              <description>
                <para>false </para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="P:System.Timers.Timer.Interval" /> </para>
              </term>
              <description>
                <para>100 milliseconds </para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="P:System.Timers.Timer.SynchronizingObject" /> </para>
              </term>
              <description>
                <para>A null reference (Nothing in Visual Basic).</para>
              </description>
            </item>
          </list>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Initializes a new instance of the <see cref="T:System.Timers.Timer" /> class, and sets all the properties to their initial values.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public Timer (double interval);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(float64 interval) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue />
      <Parameters>
        <Parameter Name="interval" Type="System.Double" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This constructor sets the <see cref="P:System.Timers.Timer.Interval" /> property of the new timer instance, but does not enable the timer.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Initializes a new instance of the <see cref="T:System.Timers.Timer" /> class, and sets the <see cref="P:System.Timers.Timer.Interval" /> property to the specified number of milliseconds.</para>
        </summary>
        <param name="interval">
          <attribution license="cc4" from="Microsoft" modified="false" />The time, in milliseconds, between events. The value must be greater than zero and less than or equal to <see cref="F:System.Int32.MaxValue" />.</param>
      </Docs>
    </Member>
    <Member MemberName="AutoReset">
      <MemberSignature Language="C#" Value="public bool AutoReset { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool AutoReset" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.ComponentModel.Category("Behavior")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.ComponentModel.DefaultValue(true)</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.Timers.TimersDescription("Indicates whether the timer will be restarted when it is enabled.")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
      </Parameters>
      <Docs>
        <value>true if the timer will raise the Elapsed event multiple times when Interval passes, false if it will raise it just once.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>If the <see cref="T:System.Timers.Timer" /> is already enabled when the <see cref="M:System.Timers.Timer.Start" /> method is called, the interval is reset. If <see cref="P:System.Timers.Timer.AutoReset" /> is false, the <see cref="M:System.Timers.Timer.Start" /> method must be called in order to start the count again.</para>
          <para>Resetting the interval affects when the <see cref="E:System.Timers.Timer.Elapsed" /> event is raised. For example, if you set the interval to 5 seconds and then set the <see cref="P:System.Timers.Timer.Enabled" /> property to true, the count starts at the time <see cref="P:System.Timers.Timer.Enabled" /> is set. If you reset the interval to 10 seconds when the count is 3 seconds, the <see cref="E:System.Timers.Timer.Elapsed" /> event is raised for the first time 13 seconds after the <see cref="P:System.Timers.Timer.Enabled" /> property was set to true.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets or sets a value indicating whether the <see cref="T:System.Timers.Timer" /> should raise the <see cref="E:System.Timers.Timer.Elapsed" /> event each time the specified interval elapses or only after the first time it elapses.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="BeginInit">
      <MemberSignature Language="C#" Value="public void BeginInit ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void BeginInit() cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The vsprvslong design environment uses this method to start the initialization of a component that is used on a form or by another component. The <see cref="M:System.Timers.Timer.EndInit" /> method ends the initialization. Using the <see cref="M:System.Timers.Timer.BeginInit" /> and <see cref="M:System.Timers.Timer.EndInit" /> methods prevents the control from being used before it is fully initialized.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Begins the run-time initialization of a <see cref="T:System.Timers.Timer" /> that is used on a form or by another component.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="Close">
      <MemberSignature Language="C#" Value="public void Close ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Close() cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <remarks>This has the same effect as calling <see cref="M:System.Timers.Timer.Stop()" />, or setting <see cref="P:System.Timers.Timer.Enabled" /> to false.</remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Releases the resources used by the <see cref="T:System.Timers.Timer" />.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="Dispose">
      <MemberSignature Language="C#" Value="protected override void Dispose (bool disposing);" />
      <MemberSignature Language="ILAsm" Value=".method familyhidebysig virtual instance void Dispose(bool disposing) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="disposing" Type="System.Boolean" />
      </Parameters>
      <Docs>
        <remarks>Disables and disposes of the timer component.</remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Releases all resources used by the current <see cref="T:System.Timers.Timer" />.</para>
        </summary>
        <param name="disposing">
          <attribution license="cc4" from="Microsoft" modified="false" />true to release both managed and unmanaged resources; false to release only unmanaged resources. </param>
      </Docs>
    </Member>
    <Member MemberName="Elapsed">
      <MemberSignature Language="C#" Value="public event System.Timers.ElapsedEventHandler Elapsed;" />
      <MemberSignature Language="ILAsm" Value=".event class System.Timers.ElapsedEventHandler Elapsed" />
      <MemberType>Event</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.ComponentModel.Category("Behavior")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.Timers.TimersDescription("Occurs when the Interval has elapsed.")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Timers.ElapsedEventHandler</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>If <see cref="P:System.Timers.Timer.Enabled" /> is set to true and <see cref="P:System.Timers.Timer.AutoReset" /> is set to false, the <see cref="T:System.Timers.Timer" /> raises the <see cref="E:System.Timers.Timer.Elapsed" /> event only once, the first time the interval elapses.</para>
          <para>If <see cref="P:System.Timers.Timer.Interval" /> is set after the <see cref="T:System.Timers.Timer" /> has started, the count is reset. For example, if you set the interval to 5 seconds and then set <see cref="P:System.Timers.Timer.Enabled" /> to true, the count starts at the time <see cref="P:System.Timers.Timer.Enabled" /> is set. If you reset the interval to 10 seconds when count is 3 seconds, the <see cref="E:System.Timers.Timer.Elapsed" /> event is raised for the first time 13 seconds after <see cref="P:System.Timers.Timer.Enabled" /> was set to true.</para>
          <para>If the <see cref="P:System.Timers.Timer.SynchronizingObject" /> property is null, the <see cref="E:System.Timers.Timer.Elapsed" /> event is raised on a <see cref="T:System.Threading.ThreadPool" /> thread. If the processing of the <see cref="E:System.Timers.Timer.Elapsed" /> event lasts longer than <see cref="P:System.Timers.Timer.Interval" />, the event might be raised again on another <see cref="T:System.Threading.ThreadPool" /> thread. In this situation, the event handler should be reentrant.</para>
          <block subset="none" type="note">
            <para>The event-handling method might run on one thread at the same time that another thread calls the <see cref="M:System.Timers.Timer.Stop" /> method or sets the <see cref="P:System.Timers.Timer.Enabled" /> property to false. This might result in the <see cref="E:System.Timers.Timer.Elapsed" /> event being raised after the timer is stopped. The example code for the <see cref="M:System.Timers.Timer.Stop" /> method shows one way to avoid this race condition.</para>
          </block>
          <para>Even if <see cref="P:System.Timers.Timer.SynchronizingObject" /> is not null, <see cref="E:System.Timers.Timer.Elapsed" /> events can occur after the <see cref="Overload:System.Timers.Timer.Dispose" /> or <see cref="M:System.Timers.Timer.Stop" /> method has been called or after the <see cref="P:System.Timers.Timer.Enabled" /> property has been set to false, because the signal to raise the <see cref="E:System.Timers.Timer.Elapsed" /> event is always queued for execution on a thread pool thread. One way to resolve this race condition is to set a flag that tells the event handler for the <see cref="E:System.Timers.Timer.Elapsed" /> event to ignore subsequent events. </para>
          <para>The <see cref="T:System.Timers.Timer" /> component catches and suppresses all exceptions thrown by event handlers for the <see cref="E:System.Timers.Timer.Elapsed" /> event. This behavior is subject to change in future releases of the .NET Framework.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Occurs when the interval elapses.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="Enabled">
      <MemberSignature Language="C#" Value="public bool Enabled { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool Enabled" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.ComponentModel.Category("Behavior")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.ComponentModel.DefaultValue(false)</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.Timers.TimersDescription("Indicates whether the timer is enabled to fire events at a defined interval.")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
      </Parameters>
      <Docs>
        <value>Boolean true if this timer is enabled, or boolean false if this timer is disabled.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Setting <see cref="P:System.Timers.Timer.Enabled" /> to true is the same as calling <see cref="M:System.Timers.Timer.Start" />, while setting <see cref="P:System.Timers.Timer.Enabled" /> to false is the same as calling <see cref="M:System.Timers.Timer.Stop" />.</para>
          <block subset="none" type="note">
            <para>The signal to raise the <see cref="E:System.Timers.Timer.Elapsed" /> event is always queued for execution on a <see cref="T:System.Threading.ThreadPool" /> thread. This might result in the <see cref="E:System.Timers.Timer.Elapsed" /> event being raised after the <see cref="P:System.Timers.Timer.Enabled" /> property is set to false. The code example for the <see cref="M:System.Timers.Timer.Stop" /> method shows one way to work around this race condition.</para>
          </block>
          <para>If <see cref="P:System.Timers.Timer.Enabled" /> is set to true and <see cref="P:System.Timers.Timer.AutoReset" /> is set to false, the <see cref="T:System.Timers.Timer" /> raises the <see cref="E:System.Timers.Timer.Elapsed" /> event only once, the first time the interval elapses.</para>
          <para>If the interval is set after the <see cref="T:System.Timers.Timer" /> has started, the count is reset. For example, if you set the interval to 5 seconds and then set the <see cref="P:System.Timers.Timer.Enabled" /> property to true, the count starts at the time <see cref="P:System.Timers.Timer.Enabled" /> is set. If you reset the interval to 10 seconds when count is 3 seconds, the <see cref="E:System.Timers.Timer.Elapsed" /> event is raised for the first time 13 seconds after <see cref="P:System.Timers.Timer.Enabled" /> was set to true.</para>
          <block subset="none" type="note">
            <para>Some visual designers, such as those in Microsoft Visual Studio, set the <see cref="P:System.Timers.Timer.Enabled" /> property to true when inserting a new <see cref="T:System.Timers.Timer" />. </para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets or sets a value indicating whether the <see cref="T:System.Timers.Timer" /> should raise the <see cref="E:System.Timers.Timer.Elapsed" /> event.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="EndInit">
      <MemberSignature Language="C#" Value="public void EndInit ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void EndInit() cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The vsprvslong design environment uses this method to end the initialization of a component that is used on a form or by another component. The <see cref="M:System.Timers.Timer.BeginInit" /> method starts the initialization. Using the <see cref="M:System.Timers.Timer.BeginInit" /> and <see cref="M:System.Timers.Timer.EndInit" /> methods prevents the control from being used before it is fully initialized.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Ends the run-time initialization of a <see cref="T:System.Timers.Timer" /> that is used on a form or by another component.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="Interval">
      <MemberSignature Language="C#" Value="public double Interval { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance float64 Interval" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.ComponentModel.Category("Behavior")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.ComponentModel.DefaultValue(100)</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.ComponentModel.RecommendedAsConfigurable(true)</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.Timers.TimersDescription("The number of milliseconds between timer events.")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Double</ReturnType>
      </ReturnValue>
      <Parameters>
      </Parameters>
      <Docs>
        <value>Double value representing the number of milliseconds for the interval.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>If the interval is set after the <see cref="T:System.Timers.Timer" /> has started, the count is reset. For example, if you set the interval to 5 seconds and then set the <see cref="P:System.Timers.Timer.Enabled" /> property to true, the count starts at the time <see cref="P:System.Timers.Timer.Enabled" /> is set. If you reset the interval to 10 seconds when count is 3 seconds, the <see cref="E:System.Timers.Timer.Elapsed" /> event is raised for the first time 13 seconds after <see cref="P:System.Timers.Timer.Enabled" /> was set to true.</para>
          <para>If <see cref="P:System.Timers.Timer.Enabled" /> is set to true and <see cref="P:System.Timers.Timer.AutoReset" /> is set to false, the <see cref="T:System.Timers.Timer" /> raises the <see cref="E:System.Timers.Timer.Elapsed" /> event only once, the first time the interval elapses. <see cref="P:System.Timers.Timer.Enabled" /> is then set to false.</para>
          <block subset="none" type="note">
            <para>If <see cref="P:System.Timers.Timer.Enabled" /> and <see cref="P:System.Timers.Timer.AutoReset" /> are both set to false, and the timer has previously been enabled, setting the <see cref="P:System.Timers.Timer.Interval" /> property causes the <see cref="E:System.Timers.Timer.Elapsed" /> event to be raised once, as if the <see cref="P:System.Timers.Timer.Enabled" /> property had been set to true. To set the interval without raising the event, you can temporarily set the <see cref="P:System.Timers.Timer.AutoReset" /> property to true.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets or sets the interval at which to raise the <see cref="E:System.Timers.Timer.Elapsed" /> event.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="Site">
      <MemberSignature Language="C#" Value="public override System.ComponentModel.ISite Site { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class System.ComponentModel.ISite Site" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.ComponentModel.ISite</ReturnType>
      </ReturnValue>
      <Parameters>
      </Parameters>
      <Docs>
        <value>To be added: an object of type 'ComponentModel.ISite'</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Sites bind a <see cref="T:System.ComponentModel.Component" /> to a <see cref="T:System.ComponentModel.Container" /> and enable communication between them, as well as providing a way for the container to manage its components.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets or sets the site that binds the <see cref="T:System.Timers.Timer" /> to its container in design mode.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="Start">
      <MemberSignature Language="C#" Value="public void Start ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Start() cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>If <see cref="P:System.Timers.Timer.Enabled" /> is set to true and <see cref="P:System.Timers.Timer.AutoReset" /> is set to false, the <see cref="T:System.Timers.Timer" /> raises the <see cref="E:System.Timers.Timer.Elapsed" /> event only once, the first time the interval elapses. When <see cref="P:System.Timers.Timer.Enabled" /> is true and <see cref="P:System.Timers.Timer.AutoReset" /> is true, the <see cref="T:System.Timers.Timer" /> continues to raise the <see cref="E:System.Timers.Timer.Elapsed" /> event on the specified interval.</para>
          <para>You can also start timing by setting <see cref="P:System.Timers.Timer.Enabled" /> to true.</para>
          <block subset="none" type="note">
            <para>If <see cref="P:System.Timers.Timer.AutoReset" /> is false, the <see cref="M:System.Timers.Timer.Start" /> method must be called in order to start the count again.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Starts raising the <see cref="E:System.Timers.Timer.Elapsed" /> event by setting <see cref="P:System.Timers.Timer.Enabled" /> to true.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="Stop">
      <MemberSignature Language="C#" Value="public void Stop ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Stop() cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>You can also stop timing by setting <see cref="P:System.Timers.Timer.Enabled" /> to false.</para>
          <block subset="none" type="note">
            <para>The signal to raise the <see cref="E:System.Timers.Timer.Elapsed" /> event is always queued for execution on a <see cref="T:System.Threading.ThreadPool" /> thread, so the event-handling method might run on one thread at the same time that a call to the <see cref="M:System.Timers.Timer.Stop" /> method runs on another thread. This might result in the <see cref="E:System.Timers.Timer.Elapsed" /> event being raised after the <see cref="M:System.Timers.Timer.Stop" /> method is called. The code example in the next section shows one way to work around this race condition.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Stops raising the <see cref="E:System.Timers.Timer.Elapsed" /> event by setting <see cref="P:System.Timers.Timer.Enabled" /> to false.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="SynchronizingObject">
      <MemberSignature Language="C#" Value="public System.ComponentModel.ISynchronizeInvoke SynchronizingObject { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class System.ComponentModel.ISynchronizeInvoke SynchronizingObject" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.ComponentModel.Browsable(false)</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.ComponentModel.DefaultValue(null)</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.Timers.TimersDescription("The object used to marshal the event handler calls issued when an interval has elapsed.")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.ComponentModel.ISynchronizeInvoke</ReturnType>
      </ReturnValue>
      <Parameters>
      </Parameters>
      <Docs>
        <value>To be added: an object of type 'ComponentModel.ISynchronizeInvoke'</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>When <see cref="P:System.Timers.Timer.SynchronizingObject" /> is null, the method that handles the <see cref="E:System.Timers.Timer.Elapsed" /> event is called on a thread from the system-thread pool. For more information on system-thread pools, see <see cref="T:System.Threading.ThreadPool" />.</para>
          <para>When the <see cref="E:System.Timers.Timer.Elapsed" /> event is handled by a visual Windows Forms component, such as a button, accessing the component through the system-thread pool might result in an exception or just might not work. Avoid this effect by setting <see cref="P:System.Timers.Timer.SynchronizingObject" /> to a Windows Forms component, which causes the method that handles the <see cref="E:System.Timers.Timer.Elapsed" /> event to be called on the same thread that the component was created on.</para>
          <block subset="none" type="note">
            <para>Even if the <see cref="P:System.Timers.Timer.SynchronizingObject" /> property is not null, <see cref="E:System.Timers.Timer.Elapsed" /> events can occur after the <see cref="Overload:System.Timers.Timer.Dispose" /> or <see cref="M:System.Timers.Timer.Stop" /> method has been called or after the <see cref="P:System.Timers.Timer.Enabled" /> property has been set to false, because the signal to raise the <see cref="E:System.Timers.Timer.Elapsed" /> event is always queued for execution on a thread pool thread. One way to resolve this race condition is to set a flag that tells the event handler for the <see cref="E:System.Timers.Timer.Elapsed" /> event to ignore subsequent events.</para>
          </block>
          <para>If the <see cref="T:System.Timers.Timer" /> is used inside Visual Studio in a Windows Forms designer, <see cref="P:System.Timers.Timer.SynchronizingObject" /> is automatically set to the control that contains the <see cref="T:System.Timers.Timer" />. For example, if you place a <see cref="T:System.Timers.Timer" /> on a designer for Form1 (which inherits from <see cref="T:System.Windows.Forms.Form" />), the <see cref="P:System.Timers.Timer.SynchronizingObject" /> property of <see cref="T:System.Timers.Timer" /> is set to the instance of Form1.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets or sets the object used to marshal event-handler calls that are issued when an interval has elapsed.</para>
        </summary>
      </Docs>
    </Member>
  </Members>
</Type>