WCF and external .config file
Hi all, it's been awhile. I've been pretty busy. Anyways, I just had a requirement, due to limitations of the software I'm working with, to load WCF configuration I had to do it from a file other than the web.config. I started out thinking this was going to be an easy task, wrong! Took a day of plugging away, but I finally found it.
My requirements were, load config from external file and be able to use the standard WCF config sections.
There are 3 main steps to this. Load the external config file. Get the configuration information for the services. Build the service objects from the config.
After a lot of framework dumpster diving (not sure where I heard it from, but it's awesome) I was finally able to figure out how to get the config sections I needed. And from there, with more diving, I was able to figure out how the objects were created.
Here is the resulting code. I have 2 classes. One of the wraps the ConfigLoader class that is used to load up the EndpointIdentity. I want to finish wrapping the ConfigLoader and see if there is anything I can remove and change to use the framework classes. These make use of reflection because of the classes and methods needed were marked as internal.
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Configuration;
using System.Reflection;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Configuration;
using System.ServiceModel.Description;
namespace WcfStuff
{
/// <summary>Provides a wrapper around the ConfigLoader class that is in the framework to create the WCF objects from config files. They marked the config loader as internal. This makes it public. Mwuahaha.
/// </summary>
public class ConfigLoader
{
private static Type _configLoaderType = null;
public static Type ConfigLoaderType
{
get
{
return _configLoaderType;
}
}
private object _configLoader = null;
static ConfigLoader()
{
Assembly executingAssembly = Assembly.GetExecutingAssembly();
AssemblyName[] referencedAssemblies = executingAssembly.GetReferencedAssemblies();
string fullAssemblyName = null;
Assembly serviceModelAssembly = null;
foreach (AssemblyName name in referencedAssemblies)
{
if (name.Name.ToLower() == "system.servicemodel")
{
fullAssemblyName = name.FullName;
break;
}
}
serviceModelAssembly = Assembly.Load(fullAssemblyName);
_configLoaderType = serviceModelAssembly.GetType("System.ServiceModel.Description.ConfigLoader");
_configureEndpointAddress = ConfigLoaderType.GetMethod("ConfigureEndpointAddress", BindingFlags.NonPublic | BindingFlags.Static);
_configureEndpointListenUriMethod = ConfigLoaderType.GetMethod("ConfigureEndpointListenUri", BindingFlags.NonPublic | BindingFlags.Static);
_loadChannelBehaviorsInstanceMethod = ConfigLoaderType.GetMethod("LoadChannelBehaviors", BindingFlags.NonPublic | BindingFlags.Instance);
_loadChannelBehaviorsStaticMethod = ConfigLoaderType.GetMethod("LoadChannelBehaviors", BindingFlags.NonPublic | BindingFlags.Static, null,
new Type[] { typeof(string), typeof(ContextInformation), typeof(KeyedByTypeCollection<IEndpointBehavior>) }, null);
_loadCommonClientBehaviorsMethod = ConfigLoaderType.GetMethod("LoadCommonClientBehaviors", BindingFlags.NonPublic | BindingFlags.Instance);
_loadDefaultEndpointBehaviorsMethod = ConfigLoaderType.GetMethod("LoadDefaultEndpointBehaviors", BindingFlags.Public | BindingFlags.Static);
_loadEndpointAddressMethod = ConfigLoaderType.GetMethod("LoadEndpointAddress", BindingFlags.NonPublic | BindingFlags.Static);
_loadHostConfigMethod = ConfigLoaderType.GetMethod("LoadHostConfig", BindingFlags.Public | BindingFlags.Instance);
_loadIdentityMethod = ConfigLoaderType.GetMethod("LoadIdentity", BindingFlags.NonPublic | BindingFlags.Static);
_loadPolicyImportersMethod = ConfigLoaderType.GetMethod("LoadPolicyImporters", BindingFlags.NonPublic | BindingFlags.Static);
_loadServiceDescriptionMethod = ConfigLoaderType.GetMethod("LoadServiceDescription", BindingFlags.Public | BindingFlags.Instance);
_loadWsdlImportsMethod = ConfigLoaderType.GetMethod("LoadWsdlImporters", BindingFlags.NonPublic | BindingFlags.Static);
_lookupBindingMethod = ConfigLoaderType.GetMethod("LookupBinding", BindingFlags.NonPublic | BindingFlags.Static, null, new Type[] { typeof(string), typeof(string) }, null);
_lookupComContractMethod = ConfigLoaderType.GetMethod("LookupComContract", BindingFlags.NonPublic | BindingFlags.Static);
_lookupContractMethod = ConfigLoaderType.GetMethod("LookupContract", BindingFlags.Public | BindingFlags.Instance);
_lookupContractForStandardEndpointMethod = ConfigLoaderType.GetMethod("LookupContractForStandardEndpoint", BindingFlags.Public | BindingFlags.Instance);
}
public ConfigLoader()
{
ConstructorInfo constructor = ConfigLoaderType.GetConstructor(Type.EmptyTypes);
_configLoader = constructor.Invoke(null);
}
private static MethodInfo _configureEndpointAddress = null;
public static MethodInfo ConfigureEndpointAddressMethod
{
get
{
return _configureEndpointAddress;
}
}
public static void ConfigureEndpointAddress(ServiceEndpointElement serviceEndpointElement, ServiceHostBase host, ServiceEndpoint endpoint)
{
ConfigureEndpointAddressMethod.Invoke(null, new object[] { serviceEndpointElement, host, endpoint });
}
private static MethodInfo _configureEndpointListenUriMethod = null;
public static MethodInfo ConfigureEndpointListenUriMethod
{
get
{
return _configureEndpointListenUriMethod;
}
}
public static void ConfigureEndpointListenUri(ServiceEndpointElement serviceEndpointElement, ServiceHostBase host, ServiceEndpoint endpoint)
{
ConfigureEndpointListenUriMethod.Invoke(null, new object[] { serviceEndpointElement, host, endpoint });
}
private static MethodInfo _loadChannelBehaviorsInstanceMethod = null;
public static MethodInfo LoadChannelBehaviorsInstanceMethod
{
get
{
return _loadChannelBehaviorsInstanceMethod;
}
}
public void LoadChannelBehaviors(ServiceEndpoint serviceEndpoint, string configurationName)
{
LoadChannelBehaviorsInstanceMethod.Invoke(_configLoader, new object[] { serviceEndpoint, configurationName });
}
private static MethodInfo _loadChannelBehaviorsStaticMethod = null;
public static MethodInfo LoadChannelBehaviorsStaticMethod
{
get
{
return _loadChannelBehaviorsStaticMethod;
}
}
public static void LoadChannelBehaviors(string behaviorName, ContextInformation context, KeyedByTypeCollection<IEndpointBehavior> channelBehaviors)
{
LoadChannelBehaviorsStaticMethod.Invoke(null, new object[] { behaviorName, context, channelBehaviors });
}
private static MethodInfo _loadCommonClientBehaviorsMethod = null;
public static MethodInfo LoadChannelBehaviorsMethod
{
get
{
return _loadCommonClientBehaviorsMethod;
}
}
public void LoadCommonClientBehaviors(ServiceEndpoint serviceEndpoint)
{
LoadChannelBehaviorsMethod.Invoke(_configLoader, new object[] { serviceEndpoint });
}
private static MethodInfo _loadDefaultEndpointBehaviorsMethod = null;
public static MethodInfo LoadDefaultEndpointBehaviorsMethod
{
get
{
return _loadDefaultEndpointBehaviorsMethod;
}
}
public static void LoadDefaultEndpointBehaviors(ServiceEndpoint endpoint)
{
LoadDefaultEndpointBehaviorsMethod.Invoke(null, new object[] { endpoint });
}
private static MethodInfo _loadEndpointAddressMethod = null;
public static MethodInfo LoadEndpointAddressMethod
{
get
{
return _loadEndpointAddressMethod;
}
}
public static EndpointAddress LoadEndpointAddress(EndpointAddressElementBase element)
{
return (EndpointAddress)LoadEndpointAddressMethod.Invoke(null, new object[] { element });
}
private static MethodInfo _loadHostConfigMethod = null;
public static MethodInfo LoadHostConfigMethod
{
get
{
return _loadHostConfigMethod;
}
}
public void LoadHostConfig(ServiceElement serviceElement, ServiceHostBase host, Action<Uri> addBaseAddress)
{
LoadHostConfigMethod.Invoke(_configLoader, new object[] { host, addBaseAddress });
}
private static MethodInfo _loadIdentityMethod = null;
public static MethodInfo LoadIdentityMethod
{
get { return _loadIdentityMethod; }
}
public static EndpointIdentity LoadIdentity(IdentityElement element)
{
return (EndpointIdentity)LoadIdentityMethod.Invoke(null, new object[] { element });
}
private static MethodInfo _loadPolicyImportersMethod = null;
public static MethodInfo LoadPolicyImportersMethod
{
get { return _loadPolicyImportersMethod; }
}
public static Collection<IPolicyImportExtension> LoadPolicyImporters(PolicyImporterElementCollection policyImporterElements, ContextInformation context)
{
return (Collection<IPolicyImportExtension>)LoadPolicyImportersMethod.Invoke(null, new object[] { policyImporterElements, context });
}
private static MethodInfo _loadServiceDescriptionMethod = null;
public static MethodInfo LoadServiceDescriptionMethod
{
get
{
return _loadServiceDescriptionMethod;
}
}
public void LoadServiceDescription(ServiceHostBase host, ServiceDescription description, ServiceElement serviceElement, Action<Uri> addBaseAddress, bool skipHost = false)
{
LoadServiceDescriptionMethod.Invoke(_configLoader, new object[] { host, description, serviceElement, addBaseAddress, skipHost });
}
private static MethodInfo _loadWsdlImportsMethod = null;
public static MethodInfo LoadWsdlImportsMethod
{
get
{
return _loadWsdlImportsMethod;
}
}
public static Collection<IWsdlImportExtension> LoadWsdlImporters(WsdlImporterElementCollection wsdlImporterElements, ContextInformation context)
{
return (Collection<IWsdlImportExtension>)LoadWsdlImportsMethod.Invoke(null, new object[] { wsdlImporterElements, context });
}
private static MethodInfo _lookupBindingMethod = null;
public static MethodInfo LookupBindingMethod
{
get
{
return _lookupBindingMethod;
}
}
public static Binding LookupBinding(string bindingSectionName, string configurationName)
{
return (Binding)LookupBindingMethod.Invoke(null, new object[] { bindingSectionName, configurationName });
}
private static MethodInfo _lookupBindingContextMethod = null;
public static MethodInfo LookupBindingContextMethod
{
get
{
return _lookupBindingContextMethod;
}
}
public static Binding LookupBinding(string bindingSectionName, string configurationName, ContextInformation context)
{
return (Binding)LookupBindingContextMethod.Invoke(null, new object[] { bindingSectionName, configurationName, context });
}
private static MethodInfo _lookupComContractMethod = null;
public static MethodInfo LookupComContractMethod
{
get
{
return _lookupComContractMethod;
}
}
public static ComContractElement LookupComContract(Guid contractIID)
{
return (ComContractElement)LookupComContractMethod.Invoke(null, new object[] { contractIID });
}
private static MethodInfo _lookupContractMethod = null;
public static MethodInfo LookupContractMethod
{
get
{
return _lookupContractMethod;
}
}
public ContractDescription LookupContract(string contractName, string serviceName)
{
return (ContractDescription)_lookupContractMethod.Invoke(_configLoader, new object[] { contractName, serviceName });
}
private static MethodInfo _lookupContractForStandardEndpointMethod = null;
public static MethodInfo LookupContractForStandardEndpointMethod
{
get
{
return _lookupContractForStandardEndpointMethod;
}
}
public ContractDescription LookupContractForStandardEndpoint(string contractName, string serviceName)
{
return (ContractDescription)LookupContractForStandardEndpointMethod.Invoke(_configLoader, new object[] { contractName, serviceName });
}
}
}
And this is the class that does all of the work creating the service
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Reflection;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Configuration;
using System.ServiceModel.Description;
namespace GuineaPigWindowsApp.WcfStuff
{
public static class ServiceResolver
{
/// <summary>Looks at a config file and will create a new instance of T using the configured settings in the config file
/// </summary>
/// <typeparam name="I">Interface of the service contract</typeparam>
/// <typeparam name="T">Service proxy to create</typeparam>
/// <param name="configFilePath">Config file that is holding the settings.</param>
/// <returns></returns>
public static T Resolve<I, T>(string configFilePath)
where I : class
where T : ClientBase<I>, new()
{
Type type = typeof(I);
string contract = type.FullName;
return Resolve<I, T>(configFilePath, contract, null);
}
/// <summary>Looks at a config file and will create a new instance of T using the configured settings the config file
/// </summary>
/// <typeparam name="T">Service proxy to create</typeparam>
/// <param name="configFilePath">Config file that is holding the settings.</param>
/// <param name="endpointName">Name of the endpoint in the config file</param>
/// <returns></returns>
public static T Resolve<I, T>(string configFilePath, string endpointName)
where I : class
where T : ClientBase<I>, new()
{
return Resolve<I, T>(configFilePath, null, endpointName);
}
/// <summary>Looks at a config file and will create a new instance of T using the configured settings the config file.
/// If contractName is null, it will look for the endpointName. Either contractName or endpointName must be defined.
/// </summary>
/// <typeparam name="T">Service proxy to create</typeparam>
/// <param name="configFilePath">Config file that is holding the settings.</param>
/// <param name="contractName">Name of the contract in the config file</param>
/// <param name="endpointName">Name of the endpoint in the config file</param>
/// <returns></returns>
public static T Resolve<I, T>(string configFilePath, string contractName, string endpointName)
where I : class
where T : ClientBase<I>, new()
{
if (contractName == null && endpointName == null)
{
throw new ArgumentException("Either contractName or endpointName must be assigned", "contractName, endpointName");
}
ExeConfigurationFileMap configMap = new ExeConfigurationFileMap();
configMap.ExeConfigFilename = configFilePath;
Configuration configuration = ConfigurationManager.OpenMappedExeConfiguration(configMap, ConfigurationUserLevel.None);
ServiceModelSectionGroup serviceModelConfig = ServiceModelSectionGroup.GetSectionGroup(configuration);
ChannelEndpointElement endpointElement = GetEndpointConfig(contractName, endpointName, serviceModelConfig);
Binding binding = GetBinding(endpointElement.Binding, endpointElement.BindingConfiguration, serviceModelConfig);
IEnumerable<IEndpointBehavior> behaviors = GetEndpointBehavior(endpointElement.BehaviorConfiguration, serviceModelConfig);
EndpointAddress endpoint = GetEndpoint(endpointElement);
T result = (T)Activator.CreateInstance(typeof(T), binding, endpoint);
foreach (IEndpointBehavior behavior in behaviors)
{
result.Endpoint.Behaviors.Add(behavior);
}
return result;
}
public static Binding GetBinding(string name, string bindingConfiguration, ServiceModelSectionGroup serviceModelConfig)
{
//find the binding
Binding result = null;
foreach (BindingCollectionElement bindingCollection in serviceModelConfig.Bindings.BindingCollections)
{
if (bindingCollection.BindingName.ToLower() == name.ToLower())
{
foreach (IBindingConfigurationElement bindingElement in bindingCollection.ConfiguredBindings)
{
if (bindingElement.Name.ToLower() == bindingConfiguration.ToLower())
{
result = (Binding)Activator.CreateInstance(bindingCollection.BindingType);
result.Name = bindingElement.Name;
bindingElement.ApplyConfiguration(result);
break;
}
}
if (result != null)
{
break;
}
}
}
return result;
}
public static IEnumerable<IEndpointBehavior> GetEndpointBehavior(string name, ServiceModelSectionGroup serviceModelConfig)
{
BehaviorsSection behaviors = serviceModelConfig.Behaviors;
EndpointBehaviorElementCollection endpointBehaviorsElements = behaviors.EndpointBehaviors;
List<IEndpointBehavior> endpointBehaviors = new List<IEndpointBehavior>();
if (!string.IsNullOrEmpty(name))
{
foreach (EndpointBehaviorElement behaviorElement in endpointBehaviorsElements)
{
if (behaviorElement.Name == name)
{
foreach (BehaviorExtensionElement behaviorExtension in behaviorElement)
{
IEndpointBehavior behavior = (IEndpointBehavior)behaviorExtension.GetType().InvokeMember("CreateBehavior",
BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance,
null, behaviorExtension, null);
endpointBehaviors.Add(behavior);
}
break;
}
}
}
return endpointBehaviors.ToArray();
}
public static ChannelEndpointElement GetEndpointConfig(string contract, string name, ServiceModelSectionGroup serviceModelConfig)
{
foreach (ChannelEndpointElement endpoint in serviceModelConfig.Client.Endpoints)
{
if ((name == null || endpoint.Name.ToLower() == name.ToLower()) && (contract == null || endpoint.Contract.ToLower() == contract.ToLower()))
{
return endpoint;
}
}
return null;
}
public static EndpointAddress GetEndpoint(ChannelEndpointElement endpointConfig)
{
EndpointAddress result = null;
result = new EndpointAddress(endpointConfig.Address, ConfigLoader.LoadIdentity(endpointConfig.Identity), endpointConfig.Headers.Headers);
return result;
}
}
}