How to handle a delegate previously associated with a method of an object that now does no longer exist?

Question

I created a duplex service (NetTcpBinding) like this example: I used the publish-subscribe pattern, and for each connection request from a new client, it creates a new instance of the service (containing a different callback). In this example, the callback is invoked through events and delegates.

Now I would like to change this example: suppose we do not want to respond immediately to client's request, that is, suppose we want to invoke the callback method after a certain time interval. In this case I need to maintain a reference to the method of the callback... But what happens if in the meantime some client disconnects? The service instance is destroyed and we lose even the callback...

I wrote this example:

• MySingletonTable is the data structure that stores the references to the methods of the callbacks;

• SampleService is not a service, but simulates the instance of a service;

  public delegate void ProcessingHandler(string item, double price, double change);
  
  public class MySingletonTable
  {
      private static volatile MySingletonTable m_Instance;
      private static object syncRoot = new object();
  
      private static Dictionary<string, ProcessingHandler> pointersToHandlers;
  
      private MySingletonTable()
      {
          pointersToHandlers = new Dictionary<string, ProcessingHandler>();
      }
  
      // Return the singleton instance of this class.
      public static MySingletonTable Instance
      {
          get
          {
              if (m_Instance == null)
              {
                  lock (syncRoot)
                  {
                      if (m_Instance == null)
                          m_Instance = new MySingletonTable();
                  }
              }
              return m_Instance;
          }
      }
  
      /// The number of the entries in the table.
      public int Count
      {
          get
          {
              lock (syncRoot)
              {
                  return pointersToHandlers.Count;
              }
          }
      }
  
      // Add an handler.
      public void Add(string id, ProcessingHandler handler)
      {
          lock (syncRoot)
          {
              if (!pointersToHandlers.ContainsKey(id))
                  pointersToHandlers.Add(id, handler);
          }
      }
  
      // Get an handler from the table.
      public ProcessingHandler GetHandler(string id)
      {
          ProcessingHandler handler = null;
          lock (syncRoot)
          {
              if (pointersToHandlers.ContainsKey(id))
                  handler = pointersToHandlers[id];
          }
          return handler;
      }
  
      // Remove the specified handler.
      public bool Remove(string id)
      {
          lock (syncRoot)
          {
              return pointersToHandlers.Remove(id);
          }
      }
  }
  
  // This class simulates the service.
  public class SampleService
  {
      private static int counter = 0;
      private int service_i = ++counter;
  
      MySingletonTable reference = MySingletonTable.Instance;
  
      public SampleService(string id)
      {
          reference.Add(id, PriceChange);
      }
  
      private void PriceChange(string item, double price, double change)
      {
          // call the callback
          // ...
          Console.WriteLine("service_i {0}: {1} {2} {3}", service_i, item, price, change);
      }
  }
  
  
  class Program
  {
      static void Main(string[] args)
      {
          SampleService s1 = new SampleService("abc");
          SampleService s2 = new SampleService("def");
  
          MySingletonTable table = MySingletonTable.Instance;
          ProcessingHandler handler = null;
  
          handler = table.GetHandler("abc");
          handler("item one", 10, 20);
  
          handler = table.GetHandler("def");
          handler("item two", 30, 40);
  
          Console.ReadLine();
      }
  }
  

Obviously I can not explicitly destroy the two service instances simulated in this example. What would happen, however, if s1 and s2 were two instances of a service related to two different clients?

Answer 1

If your delegate is stored in pointersToHandlers, then this will be holding onto your object so it is never going to be garbage collected, or as you call it, 'destroyed'. Effectively, you also have a memory leak right now.

You will need to remove the delegate from the list when clients disconnect (or whenever you are expecting the object to be destroyed). Not sure why you are not using events, but that is another question. Even if you do use events, you will still need to disconnect once you are done so that you dont end up with this situation.

Answer 2

Ok, well you are setting a local variable S1 and S2 to null. However the Dictionary still has the address to the object. The SampleService created by the new operator are not deleted when you do s1 = null, that's why calling handler after is still working. This is the same thing as doing :

var s1 = new SampleService("aa");
var handler = s1;
s1 = null;

handler is still referencing the created Object.

Answer 3

How about...

if (kDelegate.Target != null) kDelegate();