how to remove CDATA in Soap response.

 4. Modify Web.config Settings

If the CDATA is being added due to specific settings in the configuration file, you can adjust the settings to prevent CDATA from being included. 

The best approach depends on your specific requirements:

• Use a custom message encoder or message inspector for fine-grained control over the SOAP response.
• Use data contract serialization or XmlSerializer to influence how data is serialized.
• Adjust Web.config settings to modify encoding behavior.

 3. Use a Custom Message Inspector

You can implement a custom message inspector to intercept and modify the outgoing SOAP messages.

Steps:

1. Implement IDispatchMessageInspector: Create a class that implements IDispatchMessageInspector to inspect and modify the response message.

public class NoCDataMessageInspector : IDispatchMessageInspector
{
    public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
    {
        return null;
    }

    public void BeforeSendReply(ref Message reply, object correlationState)
    {
        if (reply != null)
        {
            var buffer = reply.CreateBufferedCopy(int.MaxValue);
            var message = buffer.CreateMessage();

            using (var reader = message.GetReaderAtBodyContents())
            {
                var body = reader.ReadOuterXml();
                body = body.Replace("", ""); // Remove CDATA

                var modifiedMessage = Message.CreateMessage(reply.Version, null, new XmlTextReader(new StringReader(body)));
                modifiedMessage.Headers.CopyHeadersFrom(reply);
                modifiedMessage.Properties.CopyProperties(reply.Properties);

                reply = modifiedMessage;
            }
        }
    }
}

Apply the Inspector via Behavior: Create a custom behavior and apply the message inspector to the service.

public class NoCDataBehavior : IServiceBehavior
{
    public void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
    {
        foreach (var endpoint in serviceHostBase.ChannelDispatchers.OfType())
        {
            foreach (var dispatcher in endpoint.Endpoints)
            {
                dispatcher.DispatchRuntime.MessageInspectors.Add(new NoCDataMessageInspector());
            }
        }
    }

    public void Validate(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase) { }
    public void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection endpoints, BindingParameterCollection bindingParameters) { }
}

Register the Behavior: Add the behavior to your service configuration.

var host = new ServiceHost(typeof(MyService));
host.Description.Behaviors.Add(new NoCDataBehavior());
host.Open();

 2. Modify Data Contract Serialization

If the CDATA is being added due to how the data is serialized, you can control the serialization process by implementing a custom serializer or modifying the data contract.

Use [XmlText] Attribute: If you are using DataContractSerializer, ensure that the fields/properties are marked with [XmlText] instead of [XmlElement]. This prevents the serializer from wrapping text in CDATA.

[DataContract]
public class MyResponse
{
    [DataMember]
    [XmlText]
    public string Content { get; set; }
}

Switch to XmlSerializer: If you need more control over the XML output, switch to XmlSerializer instead of DataContractSerializer. The XmlSerializer does not automatically add CDATA unless explicitly configured.

[Serializable]
public class MyResponse
{
    [XmlElement]
    public string Content { get; set; }
}

Update Service Behavior: Configure the service to use XmlSerializer by adding the following attribute to your service contract:

[ServiceContract]
[XmlSerializerFormat]
public interface IMyService
{
    [OperationContract]
    MyResponse GetData();
}

Example Code for a Custom Encoder:

public class NoCDataMessageEncoder : MessageEncoder
{
    private readonly MessageEncoder _innerEncoder;

    public NoCDataMessageEncoder(MessageEncoder innerEncoder)
    {
        _innerEncoder = innerEncoder;
    }

    public override string ContentType => _innerEncoder.ContentType;

    public override string MediaType => _innerEncoder.MediaType;

    public override Message ReadMessage(ArraySegment buffer, BufferManager bufferManager, string contentType)
    {
        return _innerEncoder.ReadMessage(buffer, bufferManager, contentType);
    }

    public override Message ReadMessage(Stream stream, int maxSizeOfHeaders, string contentType)
    {
        return _innerEncoder.ReadMessage(stream, maxSizeOfHeaders, contentType);
    }

    public override ArraySegment WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
    {
        // Intercept the message and remove CDATA
        var buffer = _innerEncoder.WriteMessage(message, maxMessageSize, bufferManager, messageOffset);
        var xml = Encoding.UTF8.GetString(buffer.Array, buffer.Offset, buffer.Count);
        xml = xml.Replace("", ""); // Remove CDATA
        var newBuffer = Encoding.UTF8.GetBytes(xml);
        return new ArraySegment(newBuffer, 0, newBuffer.Length);
    }

    public override void WriteMessage(Message message, Stream stream)
    {
        _innerEncoder.WriteMessage(message, stream);
    }
}

When developing a WCF (Windows Communication Foundation) service, the SOAP response may include sections in the XML content. This typically happens when the WCF runtime determines that certain data should be wrapped in a CDATA section to ensure it is treated as plain text and not parsed as XML. If you want to remove CDATA from the SOAP response , you can achieve this by customizing the WCF behavior or modifying how the data is serialized.

1. Use a Custom Message Encoder

You can create a custom message encoder to intercept and modify the outgoing SOAP messages. This allows you to remove the CDATA sections before the response is sent to the client.

Steps:

1. Create a Custom Message Encoder: Implement a custom encoder by inheriting from MessageEncoder.

2. Modify the SOAP Response: In the WriteMessage method of your custom encoder, parse the SOAP message and remove the CDATA sections.

3. Replace the Default Encoder: Use a custom binding to replace the default encoder with your custom encoder.

In a WCF service, if your SOAP response contains CDATA sections (like ), it is typically because the serializer is wrapping certain string content in CDATA to prevent special characters from breaking XML structure.

If you're manually serializing the response or using a custom XmlWriter, you can configure it not to write CDATA:

XmlWriterSettings settings = new XmlWriterSettings();
settings.OmitXmlDeclaration = true;
settings.CDataSectionElements.Clear(); // this removes CDATA wrapping

XmlSerializer serializer = new XmlSerializer(typeof(YourResponseType));
using (StringWriter stringWriter = new StringWriter())
using (XmlWriter writer = XmlWriter.Create(stringWriter, settings))
{
    serializer.Serialize(writer, yourResponseObject);
    string outputXml = stringWriter.ToString();
    // outputXml will not have CDATA
}

If you're using a DataContract, CDATA usually comes from using XmlCDataSection or XmlNode types. Instead, use simple strings and avoid CDATA like this:

[DataContract]
public class YourResponseType
{
    [DataMember]
    public string Message { get; set; }  // Will not use CDATA
}

If you're using IXmlSerializable and generating XML manually, make sure not to call WriteCData():

public void WriteXml(XmlWriter writer)
{
    writer.WriteElementString("Message", messageValue); // Avoid CDATA
}

If for some reason you can't avoid CDATA during serialization, you can do a string replace:

string responseXml = GetSoapResponseXml();
responseXml = responseXml.Replace("", "");