Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

I created a sessionful web service using WCF, and in particular I used the NetTcpBinding binding. In addition to methods to initiate and terminate a session, other methods allow the client to send to one or more tasks to be performed (the results are returned via callback, so the service is duplex), but they also allow you to know the status of the service.

Assuming you activate the same service on multiple endpoints, and assuming that the client knows these endpoints (for example, it could maintain a List of endpoints), the client should connect with one or more replicas of the same service. The client periodically updates the status of the service, so when it needs to perform a new task (the task is submitted by the user via UI), it selects the service currently less loaded and sends the task to it. Periodically, the client also initiates a maintenance procedure in order to disconnect from one or more overloaded service and in order to connect with new services.

I created a client proxy using the svcutil tool. I wish each proxy can be used simultaneously by different threads, for example, in addition to the thread that submits the tasks using a proxy, there are also the following two threads which act periodically:

  • a thread that periodically sends a request to the service in order to obtain the updated state;
  • a thread that periodically selects a proxy to close and instantiates a new proxy to replace the closed one.

To achieve these objectives, is it sufficient to create an array of proxies and manage their opening and closing in separate threads? I think I read that the proxy method calls are thread safe, so I would not need to perform a lock before requesting updates to the service. However, when the maintenance procedure (which is activated on its own thread) decides to close a proxy, should I perform a lock?

Finally, each proxy is also associated with an object that implements the callback interface for the service: are the callbacks (invoked on the client) executed on different threads on the client?

I would like to wrap the management of the proxy in one or more classes so that it can then easily manage within a WPF application.

share|improve this question

I created a SingleTon class that can be used to Manage this Proxy.

/// <summary>
/// Singleton Pattern
/// <para>ConnectionHelper provides connection to the Server.</para>
/// </summary>
public sealed class ConnectionHelper
    private static readonly ConnectionHelper instance = new ConnectionHelper();
    /// <summary>
    /// Provides a readonly Instance to "ConnectionHelper" class.
    /// </summary>
    public static ConnectionHelper Instance
            return instance;
    /// <summary>
    /// Provides access to IServer members.
    /// </summary>
    public ServerProxy ServerProxyInstance { get; set; }

    /// <summary>
    /// Gets or sets the peer vue communication URL.
    /// </summary>
    /// <value>The peer vue communication URL.</value>
    public string CommunicationURL

share|improve this answer

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.