Services
Technology Web App Development Mobile App Development Windows App Development Database Development UI/UX Development Cloud Development SEO Digital Marketing Guest Posting Content Writing Artificial Intelligence Data Science ERP Development CRM Development CMS Development LMS Development Business Listing Blockchain Technology Startup Promotion AI Tools Integration
Products
Data Converter Cleaner TUC - Unit Converter Import Export Survey Manager Tweet Controller
Developer
Article Blog Forum Interview Beginner News Startup Quiz
Users
Career
Apply Job Internship
Pricing
Login Sign Up Get a Quote

interview

Home Interviews How do you implement error handling in WCF (e.g., using FaultException)? – MindStick
Ask Question

1 Answers

ICSM Computer
ICSM Computer 28 May 2025
Report Abuse

In WCF, error handling is implemented primarily through the use of FaultException<T> and service behaviors like IErrorHandler. This helps return typed, user-friendly errors to clients instead of raw exceptions.

1. Using FaultException<T> for Typed Faults

Define a Fault Contract

[DataContract]
public class MyCustomFault
{
    [DataMember]
    public string ErrorMessage { get; set; }

    [DataMember]
    public string Details { get; set; }
}

Use [FaultContract] on Operations

[ServiceContract]
public interface IMyService
{
    [OperationContract]
    [FaultContract(typeof(MyCustomFault))]
    string GetData(int id);
}

Throw FaultException<T> from Service

public class MyService : IMyService
{
    public string GetData(int id)
    {
        if (id < 0)
        {
            var fault = new MyCustomFault
            {
                ErrorMessage = "Invalid ID.",
                Details = "ID must be non-negative."
            };
            throw new FaultException<MyCustomFault>(fault, "Input validation failed.");
        }

        return $"Data for ID: {id}";
    }
}

2. Catching Faults on the Client Side

try
{
    var result = client.GetData(-1);
}
catch (FaultException<MyCustomFault> ex)
{
    Console.WriteLine("Service error: " + ex.Detail.ErrorMessage);
}

3. Unhandled Exceptions — Use IErrorHandler

For unhandled server exceptions, implement IErrorHandler to catch and convert them into fault messages:

public class GlobalErrorHandler : IErrorHandler
{
    public bool HandleError(Exception error)
    {
        // Logging logic here
        return true;
    }

    public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
    {
        var customFault = new MyCustomFault
        {
            ErrorMessage = "Server Error",
            Details = error.Message
        };
        var faultException = new FaultException<MyCustomFault>(customFault);
        MessageFault msgFault = faultException.CreateMessageFault();
        fault = Message.CreateMessage(version, msgFault, faultException.Action);
    }
}

Hook into WCF via Behavior

public class ErrorBehavior : IServiceBehavior
{
    public void ApplyDispatchBehavior(ServiceDescription desc, ServiceHostBase host)
    {
        foreach (ChannelDispatcher dispatcher in host.ChannelDispatchers)
        {
            dispatcher.ErrorHandlers.Add(new GlobalErrorHandler());
        }
    }

    // Other required interface methods (empty)
}

And add it to your host:

serviceHost.Description.Behaviors.Add(new ErrorBehavior());

Summary

Technique Purpose
FaultException<T> Return typed, known faults
[FaultContract] Declare fault types in WSDL
IErrorHandler Catch and convert unhandled exceptions
FaultException (generic) Send general error with message string
MindStick Training
Markdown for AI

A clean, structured version of this page for AI assistants and LLMs.

Open .md