[ServiceContract()]
public interface IService1
{
    [OperationContract]
    string MyOperation1(string arg1, int arg2);
}
[ServiceContract()]
public interface IService2 : IService1
{
    [OperationContract]
    void MyOperation2(string value);
}

public delegate void ProxyCreatedHandler(IClientBase proxy);

/// <summary>
/// Interface to expose the inner ClientBase properties hidden by the Proxy
/// </summary>
public interface IClientBase
{
    /// <summary>
    /// Fired when a new proxy is created.
    /// In here you can initialize the Credentials and EndPoints.
    /// </summary>
    event ProxyCreatedHandler ProxyCreated;

    /// <summary>
    /// Gets the client credentials used to call an operation.
    /// Returns a System.ServiceModel.Description.ClientCredentials that represents
    /// the proof of identity presented by the client.
    /// </summary>
    ClientCredentials ClientCredentials { get; }

    /// <summary>
    /// Gets the target endpoint for the service to which the WCF client can connect.
    /// </summary>
    ServiceEndpoint Endpoint { get; }

    /// <summary>
    /// Gets the underlying System.ServiceModel.IClientChannel implementation.
    /// </summary>
    /// <value>The client channel for the WCF client object.</value>
    IClientChannel InnerChannel { get; }

    /// <summary>
    /// Gets the current state of the System.ServiceModel.ClientBase<TChannel> object.
    /// </summary>
    CommunicationState State { get; }

    /// <summary>
    /// Causes the System.ServiceModel.ClientBase<TChannel> object to transition
    //     immediately from its current state into the closed state.
    /// </summary>
    void Abort();

    /// <summary>
    /// Causes the System.ServiceModel.ClientBase<TChannel> object to transition
    //     from its current state into the closed state.
    /// </summary>
    void Close();

    /// <summary>
    /// Causes the System.ServiceModel.ClientBase<TChannel> object to transition
    //     from the created state into the opened state.
    /// </summary>
    void Open();
}

IService1 service = WCFClientProxy<IService1>.GetReusableInstance("Service1");
(service as IClientBase).ProxyCreated += new ProxyCreatedHandler(Program_ProxyCreated);

static void Program_ProxyCreated(IClientBase proxy)
{
    proxy.ClientCredentials.UserName.UserName = "myUser";
    proxy.ClientCredentials.UserName.Password = "myPassword";
}

23 Responses

1. RJ Says:
   January 16th, 2008 at 12:40 am

   Hi Corneliu,
   First, very nice work you’ve done here!

   Last time you released this dynamic clientbase proxy with the source code. Is there a possiblity that you can send me the code base? That would save me quite some work
   Thank you!

2. Corneliu Says:
   January 16th, 2008 at 8:32 am

   RJ,
   I’ve updated the link to include the source code as well.
   Enjoy,
   Corneliu.

3. Rory Primrose Says:
   March 4th, 2008 at 7:31 am

   Hi Corneliu,

   I implemented something similar, but I used RealProxy under the covers. For performance, I implemented a method cache of method handles rather than constantly resolving a MethodBase from a string name and set of parameters.

4. Corneliu Says:
   March 4th, 2008 at 8:25 am

   Rory,
   Once you create the first proxy for a specific interface I cache the proxy type so there is no need to cache the method handle anymore as all the calls are emited and there is no reflection used at all once you have the proxy instance.
   Corneliu.

5. reno Says:
   April 20th, 2008 at 12:55 pm

   How do we dispose of the client proxy? After a while it runs out of connections. I think that’s the reason ClientBase implemented IDisposable to encourage people to dispose of the client and not keep it around for a long time. Reusing the same client around in one method call or method call chain is fine, but we should drop the connection as soon as we’re done.

6. reno Says:
   April 20th, 2008 at 1:07 pm

   Nevermind ignore my last comment — I figured it out. I’m stupid

7. jeff Says:
   May 10th, 2008 at 7:54 am

   Thanks for the great source. I’m particularly interested in how you cache subsequent proxy generation. Looked through the code and don’t see it. Could you help me out to understand it?

8. jeff Says:
   May 10th, 2008 at 7:58 am

   Disregard the previous comment.

9. jeff Says:
   May 10th, 2008 at 8:04 am

   How does one actually use the code? Any samples? I see the caching and I see the classes but how you actuall use it? Please help out.

10. Corneliu Says:
    May 15th, 2008 at 12:32 pm

    Jeff,
    Part one (http://www.acorns.com.au/blog/?p=86) had example how to use the client proxy.
    Basically all you do have to do is:
    IService1 service = WCFClientProxy.GetWrappedInstance(“Service1“);
    This will get a WCF instance to your service all wrapped and ready to use.
    The code does not cache the proxy itself. It will cache the class type used to generate the proxy so next time you ask for it, it instantiates it and is ready to go.
    Regards,
    Corneliu.

11. Ben Says:
    June 13th, 2008 at 3:00 am

    Hi Corneliu,
    Have you already think about generating asynchronous operations, if they are in the interface for example with a custom attribute like this :
    void DoWork();
    [AsyncMethod(AsyncType.Begin, "DoWork")]
    void BeginDoWork();
    [AsyncMethod(AsyncType.End, "DoWork")]
    void EndDoWork();
    Your Dynamic client proxy seems to be very good, and is exactly what I was looking for but loosing asynchronous operations can be a problem in some cases I think.
    Ben.

12. Corneliu Says:
    June 13th, 2008 at 9:11 am

    Ben,
    That sounds interesting. I’ll look into that see how complex it is to build.
    Regards,
    Corneliu.

13. Garth Says:
    June 18th, 2008 at 12:47 am

    thank you been looking for a username/pwd sample all over the place

14. Darrell Says:
    August 12th, 2008 at 5:12 am

    Great code, thanks for posting it.

    I have a quick question. If I want to set my endpoint and binding programmatically, how would I do that?

    Thanks,
    Darrell

15. Pedro Says:
    September 27th, 2008 at 12:14 pm

    Hi,
    Thanks for this very nice code that I’m using in one app.
    For any reason you got a CommunicationObjectAbortedException after a inactivity period?
    I’m using net.tcp hosted on a windows service. Everything works fine until some inactivity. Calling the same operation the client throws the exception “An existing connection was forcibly closed by the remote host
    “.
    I put some wcf logging on the server and the exception is “The communication object, System.ServiceModel.Channels.ServerSessionPreambleConnectionReader+ServerFramingDuplexSessionChannel, cannot be used for communication because it has been Aborted.”
    Could this be related with the dynamic proxy?
    Thanks.

16. George Says:
    October 9th, 2008 at 6:11 pm

    Hi Corneliu

    Firstly awesome code.

    Did you have a chance to look at asynchronous operations?

    I’m using WPG and Silverlight and asynchronous is a must.

    Thanks
    George

17. George Says:
    October 9th, 2008 at 6:12 pm

    WPG?? I meant WPF.

18. Gary Says:
    October 10th, 2008 at 10:41 pm

    Thanks for sharing this Corneliu – saved me a ton of time.

19. Nate Says:
    October 16th, 2008 at 5:11 am

    This is extremely useful and well done, thank you. One issue: When I use GetReusableFaultUnwrappingInstance and an exception occurs, the outer exception is still thrown and not the inner exception. (In other words the actual fault is not unwrapped.) Could you look at that again to see if there is some bug?

20. William Says:
    November 19th, 2008 at 2:19 pm

    Hi Corneliu,

    After making 10 calls, my service starts to freeze, and have to wait 10 mins time-out before i can use it again making more calls.

    How can I increase the max connections, and also closing the proxy when its finish?

    thanks
    Will

21. Corneliu Says:
    December 15th, 2008 at 11:04 am

    Nate,
    The framework should only do that if the inner fault is NOT an exception. If the inner fault is an exception it should be properly raised. Can you please send me a sample where you have the issue.

    William,
    Like with all WCF connections you need to dispose them.
    Easiest is to cast the received interface to IClientBase and do a using for example:
    IMyService service = WCFClientProxy.GetInstance(”MyService”);
    using( (IClientBase)service )
    {
    …..
    }
    This will properly close the connection once you exit the using statement.
    Look at the IClientBase interface for more details.
    Corneliu.

22. AroglDarthu Says:
    February 5th, 2009 at 7:00 pm

    Excellent article! A few questions arose while digging through the sources though:
    There seems to be a mismatch between WCFClientProxy.RegisterEndpoint and WCFClientProxy.GetRegisteredInstance. The first builds the type with the non-reusable’ builder. The second forwards to WCFClientProxy.GetReusableInstance and results in a different type being build. Perhaps RegisterEndpoint needs an enum to indicate which builder to use?
    In the WCFAbstractReusableClientProxy.AssureProxy method a call is placed to WCFClientProxy.GetInstance… Does that mean the ‘reusability’ is limited to only once? I guess it should read GetReusableInstance here

23. parallelthinking » Blog Archive » WCF Dynamic (ClientBase) Proxy part three: Connection Pooling and Automatic Disposing Says:
    February 17th, 2009 at 2:14 pm

    [...] Automatic Disposing February 17, 2009 2:14 pm Corneliu .Net, WCF, WCF Dynamic Proxy A while ago I published a small and neat Dynamic Proxy that could be used to automatically create for you implementation of the (WCF) ClientBase<T> [...]

Leave a Comment