单例对象的实例成员或类的静态成员

Question

I am writing a listener class which creates a single HttpListener on random unused port and listens on it. I tried to make it singleton. However I am finding it difficult to keep that singleton object null when listening to random HTTP port fails 10 times.

(I have shown port number and HttpListener instance as members of singleton instance. However there are many other members that I have not shown for simplicity.) This is my code:

class Listener
{
    private static Listener listener = null;  //singleton instance

    //member variables
    private HttpListener httpListener = null;
    private int port = -1;

    static Listener()
    {
        listener = new Listener();
    } 

    private Listener()
    {
        try
        {
            port = //randomly generate
            httpListener = new HttpListener();
            //start listening
        }   
        catch(Exception ex)
        {
            //cant listen on randomly chosen port
            listener = null;
        httpListener = null;
            port = -1;
            return;            
        }   
    }
}

However inside catch() , listener = null sets listener to null just for a while. When default constructor returns it returns a new instance of Listener , thus listener inside static constructor always have instance assigned to it. Thus instead of listener = null inside default constructor it should be this = null which is invalid.

Thus I moved the whole code inside static constructor. But that forcesd me to

• Either make instance members ( port and httpListener ) static or

• or use listener.port , listener.httpListener everywhere

  class Listener { private static Listener listener = null; //singleton instance

   //member variables private HttpListener httpListener = null; private int port = -1; static Listener() { listener = new Listener(); try { listener.port = //randomly generate listener.httpListener = new HttpListener(); //start listening } catch(Exception ex) { //cant listen on randomly chosen port listener = null; return; } } private Listener() { } 

  }

I dont understand

Q1 whether to make port & httpListener static ? (This I feel somewhat against OOP principles) or

Q2 whether to keep them as instance members and use listener. everywhere? (This is problematic since there are many such members and methods in my actual code and I have to attach listener. everywhere)

Or I am thinking it all wrong and should have followed different approach?

Answer 1

The immediate problem is that on failure the instance constructor is setting the static member listener to null. However, control then returns to the static constructor which sets the static member listener to the object that was created in the instance constructor. Hence, the behaviour you're seeing.

I'd argue that your (instance) constructor is trying to do too much. I would move the 'start listening' logic into a separate method and call that from anywhere other than the instance constructor. That will make your error handling a little easier eg

class Listener
{
    public static Listener listener = null;  //singleton instance

    //member variables
    private HttpListener httpListener = null;
    private int port = -1;

    static Listener GetListener()
    {
        if (listener != null)
        {
            return listener;
        }

        try
        {
            listener = new Listener();
            listener.StartListening();
            return listener;
        }
        catch (Exception)
        {
            //cant listen on randomly chosen port
            listener.Cleanup();
            listener = null;
            throw;
        }
    }

    private Listener()
    {
        port = RandomlyGenerate();
        httpListener = new HttpListener();
    }

    private void StartListening()
    {
        //start listening
    }

    private void Cleanup()
    {
        httpListener.Close();
        httpListener = null;
        port = -1;
    }
}

Answer 2

As BartoszKP mentions in the comments, you would probably be better of with a factory pattern here.

If you are interested in having a common place for events you could place that event in the factory class, or implement a static event in the Listener class.

public class ListenerFactory {

    public IListener CreateListener(URI uri, int port) {
        Listener l = new Listener();
        l.MessageReceived += OnMessageReceived;
        // do whatever with l. loop until connection, or use l.Start() for instance
        return l;
    }

    public static event EventHandler<MessageEventArgs> ListenerMessageReceived;

    private static void OnMessageReceived(object sender, MessageEventArgs e) {
        // trigger ListenerMessageReceived
    }
}

public interface IListener {
    event EventHandler<MessageEventArgs> MessageReceived;
    void Send(byte[] data);
}

public class Listener : IListener {
    // implement interface
}

Then you just call new ListenerFactory().Create(host, port); when you need a new Listener, and if you want to listen for all messages, you subscribe to ListenerFactory.MessageReceived for incoming messages.

Using this pattern, you can create several connections at once instead of relying on one class to handle all of them.

---

You should move the initialization code of httpListener to its own method in order to avoid recreating listener. By doing that, and adding a property for getting the listener instance, classes can use Listener.Instance.Start() to reconnect if the static constructor fails to connect.

public class Listener
{
    private static Listener listener = null;  //singleton instance

    //member variables
    private HttpListener httpListener = null;
    private int port = -1;

    static Listener()
    {
        listener = new Listener();
        // start listener
        try {
             listener.Start();
         }
         catch { }
    }

    // Use this method in other classes to start listener if it fails
    // in static constructor
    public static Listener Instance { get { return listener; } }

    private Listener()
    {
    }

     public bool IsConnected {
         get { return httpListener != null; }
     }

     public void Start() 
     {
        if (IsConnected) { return; }
        try
        {
            port = //randomly generate
            httpListener = new HttpListener();
            //start listening
        }   
        catch(Exception ex)
        {
            //cant listen on randomly chosen port
        httpListener = null;
            port = -1;
            return;            
        }   
    }
}