This is a big project, so I'll post the relevant code sections.

   public partial class Connection
   {

       public static ZClient client = new ZClient();

       public static string DataRequest(int Call)
       {
           client.DataEvent += new
EventHandler<ZClient.TickPriceEventArgs>(client_Data);

           [MORE CODE]
       }

       public static string Destroy (Form1 frm)
       {

           string Result = "Disconnected";

           try
           {
               client.DataEvent -= client_DataEvent;
               client.Disconnect();
               client.Dispose();
           }

           catch (Exception e)

           {
               Result = e.ToString();
           }

           return Result;
       }

   }

The event handlers are declared in the ZClient class:

       public event EventHandler<DataEventArgs> DataEvent;

       protected virtual void OnData (DataEventArgs e)
       {
           if (Data != null)
               Data (this, e);
       }

       private void Data(int A, B, C, double D, bool E)
       {
           DataEventArgs e = new DataEventArgs(A, B, D, E);
           OnData (e);
       }

So the Connection class contains a static instance of ZClient, and the
DataRequest method subscribes to an event.  The Destroy method unsubscribes
to the event, then disposes of the object instance of the client object.

The object has now been completely disposed of.  But on a new call to
DataRequest, the methods of the ZClient class are available again (using an
instance called client), but the events are not.

It looks like this is not a new instance of the ZClient object, because the
first instance was destroyed, and it's a static member of the Connection
class.  Why then are the methods available once again, but the events not?

Thanks again for any help.