Calling a WCF Service from a Client Without Having the Contract Interface
4.91/5 (15 votes)
Calling a WCF service from a client without having the contract interface
I was asked yesterday in the Hebrew C#/.NET Framework MSDN forums a tough question – is it possible to dynamically call a WCF service using only the contract name, operation name, and metadata address?
At first, I agreed with the answer given in the forum – move from SOAP bindings to WebHttpBinding (“REST”). This of course makes things a lot easier, only requiring you to create a WebHttpRequest and parse the response. However the question remains - is it possible to do this in the case of a SOAP-based service endpoint?
The short answer is – YES!
The full answer is – YES, but you’ll need to do a lot of coding to make it work properly, and even more coding for complex scenarios (who said passing a data contract?)
How is it done, you ask?
First let’s start with the contract – you have a simple contract that looks like so:
1: [ServiceContract]
2: public interface ICalculator
3: {
4: [OperationContract]
5: double Add(double n1, double n2);
6: [OperationContract]
7: double Subtract(double n1, double n2);
8: [OperationContract]
9: double Multiply(double n1, double n2);
10: [OperationContract]
11: double Divide(double n1, double n2);
12: }
At this point, the implementation doesn’t matter, but you can assume the service compiles and loads successfully.
Second, make sure your service has either a MEX endpoint or metadata exposed over HTTP GET. Read this for more information about the difference between the two.
Third – do the client coding!!! To create the client code, I took some ideas from the following links:
- http://msdn.microsoft.com/en-us/library/ms733780.aspx – Generating client-side type information for WCF contracts
- http://www.codeproject.com/Articles/42278/Call-a-Web-Service-Without-Adding-a-Web-Reference – The same concept of dynamic calls, but for ASP.NET web services (ASMX)
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.ServiceModel;
5: using System.ServiceModel.Description;
6: using System.Globalization;
7: using System.Collections.ObjectModel;
8: using System.CodeDom.Compiler;
9:
10: namespace Client
11: {
12: class Program
13: {
14: static void Main(string[] args)
15: {
16: // Define the metadata address, contract name, operation name,
// and parameters.
17: // You can choose between MEX endpoint and HTTP GET by
// changing the address and enum value.
18: Uri mexAddress =
new Uri("http://localhost:8732/CalculatorService/?wsdl");
19: // For MEX endpoints use a MEX address and a
// mexMode of .MetadataExchange
20: MetadataExchangeClientMode mexMode = MetadataExchangeClientMode.HttpGet;
21: string contractName = "ICalculator";
22: string operationName = "Add";
23: object[] operationParameters = new object[] { 1, 2 };
24:
25: // Get the metadata file from the service.
26: MetadataExchangeClient mexClient =
new MetadataExchangeClient(mexAddress, mexMode);
27: mexClient.ResolveMetadataReferences = true;
28: MetadataSet metaSet = mexClient.GetMetadata();
29:
30: // Import all contracts and endpoints
31: WsdlImporter importer = new WsdlImporter(metaSet);
32: Collection<ContractDescription> contracts =
importer.ImportAllContracts();
33: ServiceEndpointCollection allEndpoints = importer.ImportAllEndpoints();
34:
35: // Generate type information for each contract
36: ServiceContractGenerator generator = new ServiceContractGenerator();
37: var endpointsForContracts =
new Dictionary<string, IEnumerable<ServiceEndpoint>>();
38:
39: foreach (ContractDescription contract in contracts)
40: {
41: generator.GenerateServiceContractType(contract);
42: // Keep a list of each contract's endpoints
43: endpointsForContracts[contract.Name] = allEndpoints.Where(
44: se => se.Contract.Name == contract.Name).ToList();
45: }
46:
47: if (generator.Errors.Count != 0)
48: throw new Exception("There were errors during code compilation.");
49:
50: // Generate a code file for the contracts
51: CodeGeneratorOptions options = new CodeGeneratorOptions();
52: options.BracingStyle = "C";
53: CodeDomProvider codeDomProvider = CodeDomProvider.CreateProvider("C#");
54:
55: // Compile the code file to an in-memory assembly
56: // Don't forget to add all WCF-related assemblies as references
57: CompilerParameters compilerParameters = new CompilerParameters(
58: new string[] {
59: "System.dll", "System.ServiceModel.dll",
60: "System.Runtime.Serialization.dll" });
61: compilerParameters.GenerateInMemory = true;
62:
63: CompilerResults results = codeDomProvider.CompileAssemblyFromDom(
64: compilerParameters, generator.TargetCompileUnit);
65:
66: if (results.Errors.Count > 0)
67: {
68: throw new Exception("There were errors during
generated code compilation");
69: }
70: else
71: {
72: // Find the proxy type that was generated for the specified contract
73: // (identified by a class that implements
// the contract and ICommunicationbject)
74: Type clientProxyType = results.CompiledAssembly.GetTypes().First(
75: t => t.IsClass &&
76: t.GetInterface(contractName) != null &&
77: t.GetInterface(typeof(ICommunicationObject).Name) != null);
78:
79: // Get the first service endpoint for the contract
80: ServiceEndpoint se = endpointsForContracts[contractName].First();
81:
82: // Create an instance of the proxy
83: // Pass the endpoint's binding and address as parameters
84: // to the ctor
85: object instance = results.CompiledAssembly.CreateInstance(
86: clientProxyType.Name,
87: false,
88: System.Reflection.BindingFlags.CreateInstance,
89: null,
90: new object[] { se.Binding, se.Address },
91: CultureInfo.CurrentCulture, null);
92:
93: // Get the operation's method, invoke it, and get the return value
94: object retVal = instance.GetType().GetMethod(operationName).
95: Invoke(instance, operationParameters);
96:
97: Console.WriteLine(retVal.ToString());
98: }
99: }
100: }
101: }
I’ve placed comments that describe the code, but basically it imports the WSDL, generates types for the contract (service + data), generates C# code from it, compiles it, and uses reflection to create a proxy and invoke the correct method.
If you want to use this technique to call methods that require a data contract, you will need some extra work to create the correct type and initialize it.
A compiled and running version of this code (+ the service) can be found here.
Hope you find this piece of code useful.