WCF-Exception

WCF - FaultException

---------------------------------------------------------------------------

在 WCF 中，客户端调用服务时，可能抛出的异常有以下三种类型。

1. 通讯异常。诸如网络错误，地址错误，服务器没有启动等等。这类异常多是 CommunicationException (或其具体继承类型)。
2. 状态异常。比如访问了已经关闭的代理对象，契约错误，以及安全设置错误等。常见的有 ObjectDisposedException。
3. 服务异常。由服务器触发，多是 FaultException。

针对服务异常，不同的实例管理方式会有不同的策略。

1. Pre-Call: 服务实例被释放，客户端抛出 FaultException，客户端代理对象无法继续使用。
2. Pre-Session: 服务实例被释放，会话终止。客户端抛出 FaultException，客户端代理对象无法继续使用。
3. Singleton: 服务实例依旧运行，会话终止。客户端抛出 FaultException，客户端代理对象无法继续使用。

基于平台中立和技术整合的需要，WCF 以标准 Soap Faults 方式传递异常信息。WCF 提供了 FaultException 和 FaultException<T> 两个类型来操控 Soap Faults。通过 FaultException<T> 我们可以向客户端传递一个错误信息(FaultReason)以及一个附加的详细信息(Detail)。理论上，这个附加信息是任何可以序列化的对象。

throw new FaultException<int>(123, "abc");
throw new FaultException<Exception>(new Exception("abc"));

如果想传递一个附带元数据的自定义详细信息，可以使用 FaultContract。

[DataContract]
public class ExceptionData
{
  [DataMember]
  public string Message;
}

[ServiceContract]
public interface IService
{
  [OperationContract]
  [FaultContract(typeof(ExceptionData))]
  void Test();
}

public class Service : IService, IDisposable
{
  public void Test()
  {
    ExceptionData d = new ExceptionData();
    d.Message = "xxxxxx";

    throw new FaultException<ExceptionData>(d, "abc");
  }

  public void Dispose()
  {
    Console.WriteLine("Dispose...");
  }
}

当然，我们也可以直接抛出一个被称之为 "Unknown Faults" 的 FaultException 异常实例。还有另外一种情况，你已经写好了代码，有很多……很多……的代码，要是一个个修改会非常……非常……麻烦，那么怎么在不做大的代码修改情况下传递详细异常信息给客户端呢？

方法1: ServiceBehavior(IncludeExceptionDetailInFaults=true)]

[ServiceBehavior(IncludeExceptionDetailInFaults=true)]
public class Service : IService, IDisposable
{
  public void Test()
  {
    throw new Exception("abc");
  }

  public void Dispose()
  {
    Console.WriteLine("Dispose...");
  }
}

方法2: ServiceDebugBehavior

这个比方法1要更方便一些，我们除了可以写代码外，还可以用配置文件。

ServiceHost host = new ServiceHost(typeof(Service), new Uri("http://localhost:8080/Service"));
host.AddServiceEndpoint(typeof(IService), new BasicHttpBinding(), "");

ServiceDebugBehavior debug = host.Description.Behaviors.Find<ServiceDebugBehavior>();
debug.IncludeExceptionDetailInFaults = true;

host.Open();

看看这两种方法抛出的异常是什么样的。

未处理 System.ServiceModel.FaultException`1
  Message="abc"
  Source="mscorlib"
  StackTrace:
    Server stack trace:
      在 ConsoleApplication1.localhost.IService.Test()
      在 ConsoleApplication1.localhost.ServiceClient.Test() 位置 D:/.../localhost.cs:行号 60
      在 ConsoleApplication1.Program.Main(String[] args) 位置 D:/.../Program.cs:行号 62

不错，除了 Error Message，还有详细的 stack trace，方便调试。也正因为这样，此种方法也不适合在正式项目中使用，作为系统架构设计的一部分，我们应该事先设计好异常处理。

如果服务方法是 IsOneWay=true，因不接收返回消息，客户端也就不会触发异常了。而 Callback 无非是服务器和客户端掉换个身份而已，道理相同。

public interface ICallback
{
  [OperationContract]
  void DoCallback();
}

[ServiceContract(CallbackContract=typeof(ICallback))]
public interface IService
{
  [OperationContract]
  void Test();
}

[ServiceBehavior(ConcurrencyMode=ConcurrencyMode.Reentrant)]
public class Service : IService, IDisposable
{
  public void Test()
  {
    try
    {
      OperationContext.Current.GetCallbackChannel<ICallback>().DoCallback();
    }
    catch (FaultException e)
    {
      Console.WriteLine(e);
    }
  }

  public void Dispose()
  {
    Console.WriteLine("Dispose...");
  }
}

=====================

WCF 将服务异常(Exception)转换成 SOAP faults，传递到客户端后再次转换成 Exception。只不过缺省情况下，我们很难从中获取有意义的信息。

[ServiceContract]
public interface ICalculate
{
  [OperationContract]
  int Add(int a, int b);
}

public class CalculateService : ICalculate
{
  public int Add(int a, int b)
  {
    throw new Exception("错误！");
  }
}

客户端调用 Add 方法触发异常，信息如下：

System.ServiceModel.FaultException: The server was unable to process the request due to an internal error. For more information about the error, either turn on IncludeExceptionDetailInFaults (either from ServiceBehaviorAttribute or from the <serviceDebug> configuration behavior) on the server in order to send the exception information back to the client, or turn on tracing as per the Microsoft .NET Framework 3.0 SDK documentation and inspect the server trace logs.

Server stack trace:
  在 System.ServiceModel.Channels.ServiceChannel.ThrowIfFaultUnderstood(Message reply, MessageFault fault, String action, MessageVersion version, FaultConverter faultConverter)
  ......

(我们可以使用 "(host as ServiceHost).Description.Behaviors.Find<ServiceDebugBehavior>().IncludeExceptionDetailInFaults = true;" 来启动调试行为，这样也能看到具体的出错信息！ )

当然，WCF 会提供一个包装异常类 FaultException 来帮助我们处理这些问题。

[ServiceContract]
public interface ICalculate
{
  [OperationContract]
  int Add(int a, int b);
}

public class CalculateService : ICalculate
{
  public int Add(int a, int b)
  {
    throw new FaultException(new Exception("错误！").Message);
  }
}

这次输出的信息要友好得多。

System.ServiceModel.FaultException: 错误！

Server stack trace:
  在 System.ServiceModel.Channels.ServiceChannel.HandleReply(ProxyOperationRuntime operation, ProxyRpc& rpc)
  ......

另外，我们还可以通过 FaultContractAttribute 传递更详细的异常信息给客户端。

[DataContract]
public class FaultMessage
{
  [DataMember] public string Message;
  [DataMember] public int ErrorCode;
}

[ServiceContract]
public interface ICalculate
{
  [OperationContract]
  [FaultContract(typeof(FaultMessage))]
  int Add(int a, int b);
}

public class CalculateService : ICalculate
{
  public int Add(int a, int b)
  {
    FaultMessage fault = new FaultMessage();
    fault.Message = "错误信息！";
    fault.ErrorCode = 1234;

    throw new FaultException<FaultMessage>(fault, fault.Message);
  }
}

客户端代码

try
{
  CalculateClient client = new ConsoleApplication1.localhost.CalculateClient();
  client.Add(1, 2);
}
catch (FaultException<FaultMessage> e)
{
  Console.WriteLine("{0}; {1}", e.Detail.Message, e.Detail.ErrorCode);
}