Overview of Consuming WCF Services
A WCF client never talks to a service directly; it talks through a generated proxy or a ChannelFactory-created channel that implements the same service contract interface as the server. That proxy serializes method calls into SOAP or binary messages, sends them over the configured binding's transport, and deserializes the response back into .NET objects, hiding all the wire-level plumbing from application code.
Cricket analogy: A batsman never faces the bowler's intent directly, only the ball delivered through a fixed set of rules, much like a client only ever sees the proxy's method signature, never the raw SOAP envelope underneath.
Adding a Service Reference
Visual Studio's Add Service Reference (or the older Add Web Reference) points the WCF proxy generation tool, svcutil.exe, at a service's metadata endpoint, typically exposed via WS-MetadataExchange (MEX) or an HTTP GET on the .svc?wsdl URL. svcutil reads the WSDL and its embedded XSD schemas, then emits a client-side proxy class deriving from ClientBase<TChannel>, along with data contract classes and an app.config or web.config <system.serviceModel> section describing the matching endpoint address, binding, and contract.
Cricket analogy: Reading the pitch report and team sheet before a match tells you exactly what conditions and opponents to expect, just as reading the WSDL tells svcutil exactly what operations and data types the service exposes.
ChannelFactory and Typed Clients
Instead of generating a full ClientBase proxy, many applications construct a ChannelFactory<TServiceContract> directly against the shared service contract interface (referenced from a common assembly), then call CreateChannel() to obtain a lightweight channel implementing that interface. This avoids duplicated generated code across multiple client projects and works especially well when the contract assembly is shared between service and client, though it requires the client to own the binding and endpoint address configuration explicitly rather than relying on generated config.
Cricket analogy: Using a shared team playbook instead of each player writing their own notes keeps everyone's understanding of the strategy consistent, just as a shared contract assembly keeps client and service using the exact same interface definition.
Handling Faults and Proxy Lifecycle
WCF client proxies implement ICommunicationObject and move through states such as Created, Opened, Faulted, and Closed; calling a method on a Faulted channel throws a CommunicationObjectFaultedException, and a common bug is wrapping the proxy in a using block, because if the proxy faults mid-call, Dispose() calls Close(), which itself throws on a faulted channel, masking the original exception. The recommended pattern is a try/catch around the call that explicitly calls Abort() on FaultException or CommunicationException and Close() only on success.
Cricket analogy: A batsman given out on a no-ball review still has to leave if the third umpire's final signal is out, similarly a faulted channel cannot be salvaged just by attempting normal cleanup, it must be aborted, not gracefully closed.
// ChannelFactory-based client with correct fault handling
var factory = new ChannelFactory<IOrderService>(
new BasicHttpBinding(BasicHttpSecurityMode.Transport),
new EndpointAddress("https://api.contoso.com/OrderService.svc"));
IOrderService proxy = factory.CreateChannel();
var channel = (IClientChannel)proxy;
try
{
var result = proxy.GetOrder(orderId: 4821);
Console.WriteLine($"Order total: {result.Total:C}");
channel.Close();
}
catch (FaultException fex)
{
Console.WriteLine($"Service returned a fault: {fex.Message}");
channel.Abort();
}
catch (CommunicationException)
{
channel.Abort();
throw;
}
catch (TimeoutException)
{
channel.Abort();
throw;
}Never wrap a WCF proxy in a plain using block. If the channel faults during the method call, Dispose() invokes Close(), which throws a second exception on a faulted channel and hides the real error. Always use explicit try/catch with Abort() on failure paths.
- Client proxies are generated by svcutil.exe from a service's published WSDL/MEX metadata via Add Service Reference.
- ChannelFactory<TServiceContract> plus CreateChannel() avoids generated proxy duplication when contracts are shared in a common assembly.
- Proxies implement ICommunicationObject and pass through Created, Opened, Faulted, and Closed states.
- Calling a method on a faulted channel throws CommunicationObjectFaultedException.
- Never rely on
usingblocks for WCF proxies; a fault during Dispose's implicit Close() masks the real exception. - Always Abort() on FaultException, CommunicationException, or TimeoutException, and only Close() on the success path.
- The generated app.config/web.config <client> section must match the service's actual binding configuration exactly.
Practice what you learned
1. What exception is thrown when calling a method on a faulted WCF channel?
2. Why is wrapping a WCF proxy in a `using` block discouraged?
3. What tool generates a client proxy class from a service's WSDL?
4. What must ChannelFactory<TServiceContract> clients configure explicitly that generated ClientBase proxies configure automatically?
5. What is the correct action when a FaultException is caught from a proxy call?
Was this page helpful?
You May Also Like
WCF vs gRPC
A technical comparison of WCF's SOAP-based service model against gRPC's HTTP/2 and Protocol Buffers approach, and when to choose each.
WCF Quick Reference
A condensed cheat sheet of WCF bindings, contract attributes, hosting options, and configuration essentials for day-to-day lookup.
WCF Interview Questions
Commonly asked WCF interview questions covering ABC fundamentals, bindings, contracts, instancing, and troubleshooting, with explained answers.
Related Reading
Related Study Notes in Microsoft Technologies
Browse all study notesWindows 10 / UWP Development Study Notes
.NET · 30 topics
Microsoft TechnologiesWindows Batch Scripting Study Notes
Batch · 30 topics
Microsoft TechnologiesMFC (Microsoft Foundation Classes) Study Notes
C++ · 30 topics
Microsoft TechnologiesSilverlight Study Notes
.NET · 30 topics
Microsoft TechnologiesXAML Study Notes
.NET · 30 topics
Microsoft TechnologiesWPF (Windows Presentation Foundation) Study Notes
.NET · 30 topics