/// <summary>Control that automatically updates itself when the application is idle</summary>public partial class AutoRefreshingControl : Control {    /// <summary>Initializes a new auto-updating control</summary>    public AutoRefreshingPageControl() {        this.refreshPageDelegate = new MethodInvoker(refreshPage);        this.onApplicationIdleDelegate = new EventHandler(onApplicationIdle);    }    /// <summary>    ///   Wird aufgerufen wenn die Seite sich automatisch aktualisieren kann    /// </summary>    protected virtual void OnAutoRefresh() { }    /// <summary>Immediately releases all resource owned by the instance</summary>    /// <param name="calledManually">    ///   Whether Dispose() is being called manually (not by the GC)    /// </param>    protected override void Dispose(bool calledManually) {        if (calledManually) {            if(this.autoRefreshEnabled) {                stopAutoRefresh();            }        }        base.Dispose(calledManually);    }    /// <summary>Whether automatic refreshing is currently enabled</summary>    protected bool AutoRefreshEnabled {        get {            return this.autoRefreshEnabled;        }        set {            if(value == this.autoRefreshEnabled) {              return;            }            if(value) {                startAutoRefresh();            } else {                stopAutoRefresh();            }        }    }    /// <summary>Called when the control is created</summary>    protected override void OnCreateControl() {        if(this.autoRefreshEnabled) {            if(this.autoRefreshPostponed) {                this.autoRefreshPostponed = false;                startAutoRefresh();            }        }    }    /// <summary>Begins the auto-refresh cycle</summary>    private void startAutoRefresh() {        if(Created) {            // The ignition uses a BeginInvoke() call - the application will when send itself            // a window message, meaning it won't be idle during the first call to            // refreshPage(). That means we can use the Application.Idle event for the            // next call and vice versa.            // Since we're not looping in Application.Idle, multiple controls can update            // themselves using the application's idle time.            this.refreshPageAsyncResult = BeginInvoke(this.refreshPageDelegate);            Application.Idle += this.onApplicationIdleDelegate;        } else {            // Control hasn't been created yet. Ignition needs to be deferred until the            // Control has been created.            this.autoRefreshPostponed = true;        }        this.autoRefreshEnabled = true;    }    /// <summary>Stoppt die automatische Steuerelementaktualisierung</summary>    private void stopAutoRefresh() {        Application.Idle -= this.onApplicationIdleDelegate;        // Also reset autoRefreshPostponed zurücksetzen. While a second ignition would be        // caught, this is way cleaner because no useless code execution happens in the first place.        this.autoRefreshPostponed = false;        this.autoRefreshEnabled = false;    }    /// <summary>Runs the automatic control update</summary>    private void refreshPage() {        // Was this call caused by BeginInvoke()? If so, we need to call        // EndInvoke() and leave the next call up to the Application.Idle event        if(this.refreshPageAsyncResult != null) {            EndInvoke(this.refreshPageAsyncResult);            this.refreshPageAsyncResult = null;        } else {            this.refreshPageAsyncResult = BeginInvoke(this.refreshPageDelegate);        }        // Perform the automatic refresh        OnAutoRefresh();    }    /// <summary>Called when the application becomes idle</summary>    /// <param name="sender">Not used</param>    /// <param name="arguments">Not used</param>    private void onApplicationIdle(object sender, EventArgs arguments) {        refreshPage();    }    /// <summary>Delegate for the refreshPage() method</summary>    private MethodInvoker refreshPageDelegate;    /// <summary>Delegate for the onApplicationIdle() method</summary>    private EventHandler onApplicationIdleDelegate;    /// <summary>AsyncResult returned by the updatePage() call in progress.</summary>    private volatile IAsyncResult refreshPageAsyncResult;    /// <summary>Whether automatic refreshing is currently enabled</summary>    private volatile bool autoRefreshEnabled;    /// <summary>    ///   Is set when the ignition of the auto refresh cycle wasn't possible because    ///   the control hadn't been created yet.    /// </summary>    private volatile bool autoRefreshPostponed;}