title: Is this thread.abort() normal and safe?
body: <p>I created a custom autocomplete control, when the user press a key it queries the database server (using Remoting) on another thread.  When the user types very fast, the program must cancel the previously executing request/thread.  </p>
  
  <p>I previously implemented it as AsyncCallback first, but i find it cumbersome, too many house rules to follow (e.g. AsyncResult, AsyncState, EndInvoke) plus you have to detect the thread of the BeginInvoke'd object, so you can terminate the previously executing thread.  Besides if I continued the AsyncCallback, there's no method on those AsyncCallbacks that can properly terminate previously executing thread.  </p>
  
  <p>EndInvoke cannot terminate the thread, it would still complete the operation of the to be terminated thread.  I would still end up using Abort() on thread.</p>
  
  <p>So i decided to just implement it with pure Thread approach, sans the AsyncCallback.  Is this thread.abort() normal and safe to you?</p>
  
  <pre><code>public delegate DataSet LookupValuesDelegate(LookupTextEventArgs e);
  
  internal delegate void PassDataSet(DataSet ds);
  
  public class AutoCompleteBox : UserControl
  {
     Thread _yarn = null;
  
     [System.ComponentModel.Category("Data")]
     public LookupValuesDelegate LookupValuesDelegate { set; get; }
  
     void DataSetCallback(DataSet ds)
     {
        if (this.InvokeRequired)
           this.Invoke(new PassDataSet(DataSetCallback), ds);
        else
        {
           // implements the appending of text on textbox here
        }
     }
  
     private void txt_TextChanged(object sender, EventArgs e)
     {
        if (_yarn != null) _yarn.Abort();
  
        _yarn = new Thread(
           new Mate
           {
              LookupValuesDelegate = this.LookupValuesDelegate,
              LookupTextEventArgs =
              new LookupTextEventArgs
              {
                 RowOffset = offset,
                 Filter = txt.Text
              },
              PassDataSet = this.DataSetCallback
           }.DoWork);
  
        _yarn.Start();
     }
  }
  
  
  internal class Mate
  {
     internal LookupTextEventArgs LookupTextEventArgs = null;
  
     internal LookupValuesDelegate LookupValuesDelegate = null;
  
     internal PassDataSet PassDataSet = null;
  
  
     object o = new object();
     internal void DoWork()
     {
        lock (o)
        {
           // the actual code that queries the database
           var ds = LookupValuesDelegate(LookupTextEventArgs);
           PassDataSet(ds);
        }
     }
  }
  </code></pre>
  
  <h3>NOTES</h3>
  
  <p>The reason for cancelling the previous thread when the user type keys in succession, is not only to prevent the appending of text from happening, but also to cancel the previous network roundtrip, so the program won't be consuming too much memory resulting from successive network operation.</p>
  
  <p>I'm worried if I avoid thread.Abort() altogether, the program could consume too much memory.</p>
  
  <p>here's the code without the thread.Abort(), using a counter:</p>
  
  <pre><code>internal delegate void PassDataSet(DataSet ds, int keyIndex);
  
  public class AutoCompleteBox : UserControl
  {
     [System.ComponentModel.Category("Data")]
     public LookupValuesDelegate LookupValuesDelegate { set; get; }
  
     static int _currentKeyIndex = 0;
  
     void DataSetCallback(DataSet ds, int keyIndex)
     {
        if (this.InvokeRequired)
           this.Invoke(new PassDataSet(DataSetCallback), ds, keyIndex);
        else
        {
           // ignore the returned DataSet
           if (keyIndex &lt; _currentKeyIndex) return; 
  
           // implements the appending of text on textbox here...
        }
     }
  
     private void txt_TextChanged(object sender, EventArgs e)
     {
        Interlocked.Increment(ref _currentKeyIndex);
  
        var yarn = new Thread(
           new Mate
           {
              KeyIndex = _currentKeyIndex,
              LookupValuesDelegate = this.LookupValuesDelegate,
              LookupTextEventArgs =
              new LookupTextEventArgs
              {
                 RowOffset = offset,
                 Filter = txt.Text
              },
              PassDataSet = this.DataSetCallback
           }.DoWork);
  
        yarn.Start();
     }
  }
  
  
  internal class Mate
  {
     internal int KeyIndex;
     internal LookupTextEventArgs LookupTextEventArgs = null;
     internal LookupValuesDelegate LookupValuesDelegate = null;
     internal PassDataSet PassDataSet = null;
  
     object o = new object();
     internal void DoWork()
     {
        lock (o)
        {
           // the actual code that queries the database
           var ds = LookupValuesDelegate(LookupTextEventArgs);
           PassDataSet(ds, KeyIndex);
        }
     }
  }
  </code></pre>