I hadn’t thought about your issue as the services I was using this for are pretty simple, however your solution seems to work nicely. I may add something like this into the next iteration.

Thanks for submitting your additions to it!

I do have one thought if I may…

I have a service client with multiple endpoints defined in web/app.config. Using the GetClient() method will cause an exception to be thrown because WCF can’t decide for me which endpoint to use. I edited the above method and added a new one as follows:

}

///
/// Retrieves a service client for the interface specified in generic parameter.
///
/// Interface type to use for Service Client creation.
/// Service client instance for specified interface.
public T GetClient()
{
// Passing null causes reflection to use the default constructor of the Service Client (This works if only one endpoint is defined for the service)
return GetClient(null);
}

///
/// Retrieves a service client for the interface specified in generic parameter.
///
/// Interface type to use for Service Client creation.
/// Object array of arguments to pass to the Service Client’s constuctor
/// Service client instance for specified interface.
/// The ‘ values must match the order and type of a constructor for the Service Client.
public T GetClient(params object[] constructorArgs)
{
var genericType = typeof(T);
Type serviceClientType;
if (genericType.IsInterface)
{
serviceClientType = GetClientType(genericType);

if (serviceClientType == null)
return default(T);

// Pass the supplied constructor arguments to the CreateInstance method
var client = Activator.CreateInstance(serviceClientType, constructorArgs);
if (!(client is ICommunicationObject))
{
client = null;
return (T)client;

}
(client as ICommunicationObject).Faulted += Channel_Faulted;

if (!factories.ContainsKey(typeof(T)))
{
var prop = serviceClientType.GetProperty(”ChannelFactory”);
var factory = prop.GetValue(client, null);
factories.Add(typeof(T), factory);
}
return (T)client;
}
return default(T);
}

For my personal situation, I only need to pass the endpointConfigurationName as a constructor parameter, but I think this implementation will allow for any of the service client’s constructors to be called.

I’ve tested it in a limited fashion, but wanted to see if you had any comments/concerns.

Once again thanks for pointing me in the right direction.

Microsoft does have an official Windows 7 RC Support Forum located here http://tinyurl.com/9fhdl5 . It is supported by product specialists as well as engineers and support teams. You may want to check the threads available there for additional assistance and feedback.

Jessica
Microsoft Windows Client Team

Why setting this parameter? it is not passed by ref !

Being that performance, maintenance, and repetitive code are the key factors here, I’ve found that a discussion of code generation enters the room quite gracefully. Past projects I’ve worked on that have leveraged code generation (and regeneration) always seem to have arrived there by either trying to eliminate the writing of repetitive, code like property accessors or maps, or by looking at code generation as a sort of caching mechanism that does its work pre-compile-time as opposed to doing it at runtime.

Code Generation can add that third dimension to your matrices above, allowing you to provide the performance of the static loading method, while being able to do so (with some required foresight) in a maintainable manner.

I too agree that there must be a merit to using it. Microsoft makes heavy use of Reflection techniques in many of their approaches to problem solving in 3.5,. so it looks like a strategy we should learn more about.

Thanks for reading and commenting!

Many frameworks such as Spring, Hibernate and many other ORM for database mapping use reflection, so there must be a merit to using reflection in proper manner.

Especially when using reflection to assign a value to a variable, most of people use class inspection and iterator to iterate through the properties and assign values accordingly.

The funny part is that most of the process power and time wasted happens during the property/method iteration.

This can easily resolved by caching the properties/methods information in a shared cache. If the cache is empty or stale, then iterate over the list of properties and store the information to cache.

Once the cache has the information, we can just easily do a simple value assignment without going through the class type inspectino via reflection again.

just my 2c.

-SK