WCF服务中DataContract字段为空时返回自定义错误消息的实现方法

Got it, let's tackle this problem step by step. You want to return a specific custom error structure when the Name field of your Employee DataContract is empty. First, let's define the custom error contract that matches your required structure, then implement validation and error handling in a few different ways depending on your needs.

Step 1: Define the Custom Error DataContract #

First, create a DataContract for your error response to ensure it's serialized correctly:

[DataContract]
public class CustomErrorResponse
{
    [DataMember]
    public int? ErrorCode { get; set; }
    
    [DataMember]
    public string? ErrorDesc { get; set; }
    
    [DataMember]
    public string? ErrorText { get; set; }
    
    [DataMember]
    public string? StateCode { get; set; }
}

Approach 1: Validate Directly in the Employee Property Setter #

This is a simple, inline way to validate the Name field as soon as it's set (during deserialization):

[DataContract]
public class Employee
{
    private string _name;

    [DataMember]
    public int Id { get; set; }

    [DataMember]
    public string Name
    {
        get => _name;
        set
        {
            if (string.IsNullOrWhiteSpace(value))
            {
                // Create your custom error object
                var error = new CustomErrorResponse
                {
                    ErrorCode = 111,
                    ErrorDesc = null,
                    ErrorText = null,
                    StateCode = null
                };
                // Throw a FaultException with your custom error contract
                throw new FaultException<CustomErrorResponse>(error, "Name cannot be empty or whitespace");
            }
            _name = value;
        }
    }
}

Then, update your service contract to declare this fault so clients can handle it:

[ServiceContract]
public interface IEmployeeService
{
    [OperationContract]
    [FaultContract(typeof(CustomErrorResponse))]
    void ProcessEmployee(Employee employee);
}

Approach 2: Validate in the Service Operation Method #

If you prefer to keep validation logic out of the DataContract class, you can check the Name field directly in your service method:

public class EmployeeService : IEmployeeService
{
    public void ProcessEmployee(Employee employee)
    {
        // Validate the Name field
        if (string.IsNullOrWhiteSpace(employee.Name))
        {
            var error = new CustomErrorResponse
            {
                ErrorCode = 111,
                ErrorDesc = null,
                ErrorText = null,
                StateCode = null
            };
            throw new FaultException<CustomErrorResponse>(error, "Name is a required field");
        }

        // Your business logic here
    }
}

Don't forget to add the [FaultContract(typeof(CustomErrorResponse))] attribute to your operation contract as shown in Approach 1.

Approach 3: Global Validation with a Message Inspector #

For a reusable, cross-service validation solution (so you don't have to repeat checks in every method), use an IDispatchMessageInspector to intercept requests and validate Employee instances globally:

Step 3.1: Implement the Message Inspector #

public class EmployeeValidationInspector : IDispatchMessageInspector
{
    public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
    {
        // Extract the Employee object from the request
        var requestBody = request.GetBody<Employee>();
        
        if (requestBody != null && string.IsNullOrWhiteSpace(requestBody.Name))
        {
            var error = new CustomErrorResponse
            {
                ErrorCode = 111,
                ErrorDesc = null,
                ErrorText = null,
                StateCode = null
            };
            throw new FaultException<CustomErrorResponse>(error, "Name cannot be empty");
        }
        
        return null;
    }

    public void BeforeSendReply(ref Message reply, object correlationState)
    {
        // No action needed here
    }
}

Step 3.2: Create a Service Behavior to Register the Inspector #

public class EmployeeValidationBehavior : IServiceBehavior
{
    public void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
    {
        foreach (var channelDispatcher in serviceHostBase.ChannelDispatchers)
        {
            if (channelDispatcher is ChannelDispatcher dispatcher)
            {
                foreach (var endpointDispatcher in dispatcher.Endpoints)
                {
                    endpointDispatcher.DispatchRuntime.MessageInspectors.Add(new EmployeeValidationInspector());
                }
            }
        }
    }

    public void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters)
    {
        // No action needed here
    }

    public void Validate(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
    {
        // No action needed here
    }
}

Step 3.3: Register the Behavior with Your Service Host #

using (var host = new ServiceHost(typeof(EmployeeService)))
{
    // Add the validation behavior to the service
    host.Description.Behaviors.Add(new EmployeeValidationBehavior());
    host.Open();
    Console.WriteLine("Service is running...");
    Console.ReadLine();
}

Key Notes #

• Make sure your service configuration doesn't set includeExceptionDetailInFaults="true" in production (this is for debugging only). Since we're using FaultException<T>, the custom error will be returned properly without exposing internal details.
• Clients can catch the FaultException<CustomErrorResponse> to handle the error explicitly.

内容的提问来源于stack exchange，提问作者thegautamnayak