What is the Preferred Way to Handle Hangup Events?

public class Disconnect
{
    public ChannelResource ChannelResource
    {
        get;
        set;
    }
 
    public VoiceResource VoiceResource
    {
        get;
        set;
    }
 
    public TelephonyServer TelephonyServer
    {
        get;
        set;
    }
 
    public Log Log
    {
        get;
        set;
    }
 
    public string DeviceName
    {
        get;
        set;
    }
 
 
    public Disconnect(ChannelResource channelResource, TelephonyServer telephonyServer, Log log)
    {
        ChannelResource = channelResource;
        DeviceName = ChannelResource.DeviceName;
        VoiceResource = channelResource.VoiceResource;
        TelephonyServer = telephonyServer;
        Log = log;
    }
 
    public string PhoneNumber
    {
        get;
        set;
    }
 
    public ChannelResource OutboundChannelResource
    {
        get;
        set;
    }
 
    public System.Threading.ManualResetEvent HangupEvent = new System.Threading.ManualResetEvent(false);
 
    public void RunScript()
    {
        try
        {
            // This assumes that someone is on the line and we would like to dial out
 
            // Register the hangup event to the inbound channel
            // The hangup event will trigger the ManualResetEvent HangupEvent so that the "WaitOne" below will return once this line disconnects
            ChannelResource.Disconnected +=new VoiceElements.Client.Disconnected(ChannelResource_Disconnected);
 
            // Get a Channel to dial out on.
            OutboundChannelResource = TelephonyServer.GetChannel();
 
            // Subscribe the OutboundChannel to the Disconnected event. By subscribing both to the same event, when either side disconnects, it will cause the "WaitOne" below to return
            OutboundChannelResource.Disconnected +=new VoiceElements.Client.Disconnected(ChannelResource_Disconnected);
 
            // We route the two channels together...When we do this before dialing, the inbound channel, should be able to hear ringing.
            OutboundChannelResource.RouteFull(ChannelResource);
 
            // Dial
            OutboundChannelResource.Dial(PhoneNumber);
 
            // Once the call connects, the person on the inbound channel resource should be able to speak with the person on the outbound channel resource
            // We can then wait until we disconnect, before the finally block get's executed.
 
            // When called with no parameters it will wait indefinitely, until "Set" is called on the Reset Event
            HangupEvent.WaitOne();
 
            // Alternatively, you can pass in a timeout period (perhaps 60 minutes)
            //HangupEvent.WaitOne(3600000);
        }
        catch (HangupException hex)
        {
            Log.WriteWithId(DeviceName, "Caller Hungup!");
        }
        catch (Exception ex)
        {
            Log.WriteException(ex, "Unexpected exception: {0}", DeviceName);
        }
        finally
        {
            // Make sure you unsubscribe from your events
            try
            {
                ChannelResource.Disconnected -= new VoiceElements.Client.Disconnected(ChannelResource_Disconnected);
            }
            catch{}
 
            if(OutboundChannelResource != null)
             {
                 try
                 {
                     OutboundChannelResource.Disconnect();
                 }
                 catch { }
 
                 try
                 {
                     ChannelResource.Disconnected -= new VoiceElements.Client.Disconnected(ChannelResource_Disconnected);
                 }
                 catch{}
 
                 try
                 {
                     OutboundChannelResource.Dispose();
                 }
                 catch { }
                 }
             }
 
               try
               {
                   ChannelResource.Disconnect();
               }
               catch { }
 
               try
               {
                   ChannelResource.Dispose();
               }
               catch { }
               }
 
            try
            {
                ChannelResource.Disconnect();
            }
            catch { }
 
            try
            {
                ChannelResource.Dispose();
            }
            catch { }
        }
    }
 
    void ChannelResource_Disconnected(object sender, VoiceElements.Client.DisconnectedEventArgs e)
    {
        Log.Write("Received Disconnect!"); 
        HangupEvent.Set();
    }
}