CODEWITHSUNDEEP
c#wcfproxy
Vincent van der Weele
Vincent van der Weele

Reputation: 13187

How does __TransparentProxy work?

When using WCF, we can define a service contract:

[ServiceContract]
public interface IMyService
{
    [OperationContract]
    int MyOperation(int x);
}

Assume I open a servicehost at www.example.com/MyService, then one way to use this service from my client is

IMyService service =
    new ChannelFactory<IMyService>(new BasicHttpBinding(),
        new EndpointAddress("www.example.com/MyService")).CreateChannel();
int result = service.MyOperation(10);

So somehow, service implements IMyService, although that was never done explicitly. If I debug these lines, I can see that service is an instance of __TransparentProxy. As you can see from the source code, the comments in that class say

Transparent proxy magically creates a message that represents a call on it and delegates to the Real proxy to do the real remoting work.

To me this is indeed 'magic', but I guess there must be a logical explanation.

The pattern here can be very useful. What I would like is some class like Magic below (the syntax is incorrect, I know, otherwise I wouldn't need to ask). For the sake of argument, let's say I want this class to print the name of the method called.

public class Magic<T> : T {
    // don't know what to do here
}

Such that I would be able to call

IMyService service = new Magic<IMyService>();
service.MyOperation(10);

And this would print:

MyOperation

Is something like this possible? (It should be, since __TransparentProxy does something similar.) And if so, how would this work?

Upvotes: 3

Views: 1380

Answers (2)

Drew Delano
Drew Delano

Reputation: 1509

Any one else running across this answer might want to look at Aspect Oriented Programming (AOP) in general

And possibly PostSharp specifically: https://www.postsharp.net/aop.net

Upvotes: 0

Lawrence
Lawrence

Reputation: 3297

There are a few articles on Codeplex that try to do something similar to what WCF does under the covers:

http://www.codeproject.com/Articles/43598/Emit-Proxy http://www.codeproject.com/Articles/5511/Dynamic-Proxy-Creation-Using-C-Emit

The System.Reflection.Emit namespace is the underlying key, which can be used to dynamically create .NET assemblies and types in code.

Upvotes: 3

Related Questions