|
//----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Globalization;
using System.Runtime;
using System.ServiceModel;
using System.Xml;
abstract class WsrmFault : MessageFault
{
FaultCode code;
string exceptionMessage;
bool hasDetail;
bool isRemote;
FaultReason reason;
ReliableMessagingVersion reliableMessagingVersion;
string subcode;
// local
protected WsrmFault(bool isSenderFault, string subcode, string faultReason, string exceptionMessage)
{
if (isSenderFault)
{
this.code = new FaultCode("Sender", "");
}
else
{
this.code = new FaultCode("Receiver", "");
}
this.subcode = subcode;
this.reason = new FaultReason(faultReason, CultureInfo.CurrentCulture);
this.exceptionMessage = exceptionMessage;
this.isRemote = false;
}
// remote
protected WsrmFault(FaultCode code, string subcode, FaultReason reason)
{
this.code = code;
this.subcode = subcode;
this.reason = reason;
this.isRemote = true;
}
public override FaultCode Code
{
get
{
return this.code;
}
}
public override bool HasDetail
{
get
{
// The SOAP 1.1 requires body processing error information to be placed in a detail element
// and header processing error information to be placed in a soap fault header.
// Since wsrm header faults relate to header processing, the information in the detail is placed in a
// soap fault header in the SOAP 1.1 case. SOAP 1.2 is not so restrictive. Thus, this flag is set
// in CreateMessage if the SOAP version is 1.2.
return this.hasDetail;
}
}
public bool IsRemote
{
get
{
return this.isRemote;
}
}
public override FaultReason Reason
{
get
{
return this.reason;
}
}
public string Subcode
{
get
{
return this.subcode;
}
}
public virtual CommunicationException CreateException()
{
string message;
if (this.IsRemote)
{
message = FaultException.GetSafeReasonText(this.reason);
message = SR.GetString(SR.WsrmFaultReceived, message);
}
else
{
if (this.exceptionMessage == null)
{
throw Fx.AssertAndThrow("Exception message must not be accessed unless set.");
}
message = this.exceptionMessage;
}
if (this.code.IsSenderFault)
return new ProtocolException(message);
else
return new CommunicationException(message);
}
public static CommunicationException CreateException(WsrmFault fault)
{
return fault.CreateException();
}
public Message CreateMessage(MessageVersion messageVersion, ReliableMessagingVersion reliableMessagingVersion)
{
this.SetReliableMessagingVersion(reliableMessagingVersion);
string action = WsrmIndex.GetFaultActionString(messageVersion.Addressing, reliableMessagingVersion);
if (messageVersion.Envelope == EnvelopeVersion.Soap11)
{
this.code = this.Get11Code(this.code, this.subcode);
}
else if (messageVersion.Envelope == EnvelopeVersion.Soap12)
{
if (this.code.SubCode == null)
{
FaultCode subCode = new FaultCode(this.subcode,
WsrmIndex.GetNamespaceString(reliableMessagingVersion));
this.code = new FaultCode(this.code.Name, this.code.Namespace, subCode);
}
this.hasDetail = this.Get12HasDetail();
}
else
{
throw Fx.AssertAndThrow("Unsupported MessageVersion.");
}
Message message = Message.CreateMessage(messageVersion, this, action);
this.OnFaultMessageCreated(messageVersion, message);
return message;
}
protected abstract FaultCode Get11Code(FaultCode code, string subcode);
protected abstract bool Get12HasDetail();
protected string GetExceptionMessage()
{
if (this.exceptionMessage == null)
{
throw Fx.AssertAndThrow("Exception message must not be accessed unless set.");
}
return this.exceptionMessage;
}
protected ReliableMessagingVersion GetReliableMessagingVersion()
{
if (this.reliableMessagingVersion == null)
{
throw Fx.AssertAndThrow("Reliable messaging version must not be accessed unless set.");
}
return this.reliableMessagingVersion;
}
protected abstract void OnFaultMessageCreated(MessageVersion version, Message message);
protected void SetReliableMessagingVersion(ReliableMessagingVersion reliableMessagingVersion)
{
if (reliableMessagingVersion == null)
{
throw Fx.AssertAndThrow("Reliable messaging version cannot be set to null.");
}
if (this.reliableMessagingVersion != null)
{
throw Fx.AssertAndThrow("Reliable messaging version must not be set twice.");
}
this.reliableMessagingVersion = reliableMessagingVersion;
}
internal void WriteDetail(XmlDictionaryWriter writer)
{
this.OnWriteDetailContents(writer);
}
}
class WsrmRequiredFault : WsrmFault
{
// local
public WsrmRequiredFault(string faultReason)
: base(true, Wsrm11Strings.WsrmRequired, faultReason, null)
{
}
protected override FaultCode Get11Code(FaultCode code, string subcode)
{
return new FaultCode(subcode, WsrmIndex.GetNamespaceString(this.GetReliableMessagingVersion()));
}
protected override bool Get12HasDetail()
{
return false;
}
protected override void OnFaultMessageCreated(MessageVersion version, Message message)
{
// do nothing
}
protected override void OnWriteDetailContents(XmlDictionaryWriter writer)
{
// do nothing
}
}
abstract class WsrmHeaderFault : WsrmFault
{
bool faultsInput;
bool faultsOutput;
UniqueId sequenceID;
string subcode;
// local
protected WsrmHeaderFault(bool isSenderFault, string subcode, string faultReason, string exceptionMessage,
UniqueId sequenceID, bool faultsInput, bool faultsOutput)
: base(isSenderFault, subcode, faultReason, exceptionMessage)
{
this.subcode = subcode;
this.sequenceID = sequenceID;
this.faultsInput = faultsInput;
this.faultsOutput = faultsOutput;
}
// remote
protected WsrmHeaderFault(FaultCode code, string subcode, FaultReason reason, XmlDictionaryReader detailReader,
ReliableMessagingVersion reliableMessagingVersion, bool faultsInput, bool faultsOutput)
: this(code, subcode, reason, faultsInput, faultsOutput)
{
this.sequenceID = ParseDetail(detailReader, reliableMessagingVersion);
}
// remote
protected WsrmHeaderFault(FaultCode code, string subcode, FaultReason reason, bool faultsInput,
bool faultsOutput)
: base(code, subcode, reason)
{
this.subcode = subcode;
this.faultsInput = faultsInput;
this.faultsOutput = faultsOutput;
}
public bool FaultsInput
{
get
{
return this.faultsInput;
}
}
public bool FaultsOutput
{
get
{
return this.faultsOutput;
}
}
public UniqueId SequenceID
{
get
{
return this.sequenceID;
}
protected set
{
this.sequenceID = value;
}
}
static WsrmHeaderFault CreateWsrmHeaderFault(ReliableMessagingVersion reliableMessagingVersion, FaultCode code,
string subcode, FaultReason reason, XmlDictionaryReader detailReader)
{
// Sender faults.
if (code.IsSenderFault)
{
if (subcode == WsrmFeb2005Strings.InvalidAcknowledgement)
{
return new InvalidAcknowledgementFault(code, reason, detailReader, reliableMessagingVersion);
}
else if (subcode == WsrmFeb2005Strings.MessageNumberRollover)
{
return new MessageNumberRolloverFault(code, reason, detailReader, reliableMessagingVersion);
}
else if (subcode == WsrmFeb2005Strings.UnknownSequence)
{
return new UnknownSequenceFault(code, reason, detailReader, reliableMessagingVersion);
}
else if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
if (subcode == WsrmFeb2005Strings.LastMessageNumberExceeded)
{
return new LastMessageNumberExceededFault(code, reason, detailReader, reliableMessagingVersion);
}
}
else if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
if (subcode == Wsrm11Strings.SequenceClosed)
{
return new SequenceClosedFault(code, reason, detailReader, reliableMessagingVersion);
}
}
}
// Sender or receiver faults.
if (code.IsSenderFault || code.IsReceiverFault)
{
return new SequenceTerminatedFault(code, reason, detailReader, reliableMessagingVersion);
}
return null;
}
protected override FaultCode Get11Code(FaultCode code, string subcode)
{
return code;
}
protected override bool Get12HasDetail()
{
return true;
}
static void LookupDetailInformation(ReliableMessagingVersion reliableMessagingVersion, string subcode,
out string detailName, out string detailNamespace)
{
detailName = null;
detailNamespace = null;
string wsrmNs = WsrmIndex.GetNamespaceString(reliableMessagingVersion);
bool wsrmFeb2005 = reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005;
bool wsrm11 = reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
if (subcode == WsrmFeb2005Strings.InvalidAcknowledgement)
{
detailName = WsrmFeb2005Strings.SequenceAcknowledgement;
detailNamespace = wsrmNs;
}
else if ((subcode == WsrmFeb2005Strings.MessageNumberRollover)
|| (subcode == WsrmFeb2005Strings.SequenceTerminated)
|| (subcode == WsrmFeb2005Strings.UnknownSequence)
|| (wsrmFeb2005 && (subcode == WsrmFeb2005Strings.LastMessageNumberExceeded))
|| (wsrm11 && (subcode == Wsrm11Strings.SequenceClosed)))
{
detailName = WsrmFeb2005Strings.Identifier;
detailNamespace = wsrmNs;
}
else
{
detailName = null;
detailNamespace = null;
}
}
protected override void OnFaultMessageCreated(MessageVersion version, Message message)
{
if (version.Envelope == EnvelopeVersion.Soap11)
{
WsrmSequenceFaultHeader header = new WsrmSequenceFaultHeader(this.GetReliableMessagingVersion(), this);
message.Headers.Add(header);
}
}
protected override void OnWriteDetailContents(XmlDictionaryWriter writer)
{
WsrmUtilities.WriteIdentifier(writer, this.GetReliableMessagingVersion(), this.sequenceID);
}
static UniqueId ParseDetail(XmlDictionaryReader reader, ReliableMessagingVersion reliableMessagingVersion)
{
try
{
return WsrmUtilities.ReadIdentifier(reader, reliableMessagingVersion);
}
finally
{
reader.Close();
}
}
public static bool TryCreateFault11(ReliableMessagingVersion reliableMessagingVersion, Message message,
MessageFault fault, int index, out WsrmHeaderFault wsrmFault)
{
if (index == -1)
{
wsrmFault = null;
return false;
}
// All wsrm header faults must be sender or receiver faults.
if (!fault.Code.IsSenderFault && !fault.Code.IsReceiverFault)
{
wsrmFault = null;
return false;
}
string subcodeName = WsrmSequenceFaultHeader.GetSubcode(message.Headers.GetReaderAtHeader(index),
reliableMessagingVersion);
if (subcodeName == null)
{
wsrmFault = null;
return false;
}
string detailName;
string detailNamespace;
LookupDetailInformation(reliableMessagingVersion, subcodeName, out detailName, out detailNamespace);
XmlDictionaryReader detailReader = WsrmSequenceFaultHeader.GetReaderAtDetailContents(detailName,
detailNamespace, message.Headers.GetReaderAtHeader(index), reliableMessagingVersion);
if (detailReader == null)
{
wsrmFault = null;
return false;
}
wsrmFault = CreateWsrmHeaderFault(reliableMessagingVersion, fault.Code, subcodeName, fault.Reason,
detailReader);
if (wsrmFault != null)
{
message.Headers.UnderstoodHeaders.Add(message.Headers[index]);
return true;
}
else
{
return false;
}
}
public static bool TryCreateFault12(ReliableMessagingVersion reliableMessagingVersion, Message message,
MessageFault fault, out WsrmHeaderFault wsrmFault)
{
// All wsrm header faults must be sender or receiver faults.
if (!fault.Code.IsSenderFault && !fault.Code.IsReceiverFault)
{
wsrmFault = null;
return false;
}
if ((fault.Code.SubCode == null)
|| (fault.Code.SubCode.Namespace != WsrmIndex.GetNamespaceString(reliableMessagingVersion)) || !fault.HasDetail)
{
wsrmFault = null;
return false;
}
string subcodeName = fault.Code.SubCode.Name;
XmlDictionaryReader detailReader = fault.GetReaderAtDetailContents();
wsrmFault = CreateWsrmHeaderFault(reliableMessagingVersion, fault.Code, subcodeName, fault.Reason,
detailReader);
return (wsrmFault != null);
}
}
sealed class InvalidAcknowledgementFault : WsrmHeaderFault
{
SequenceRangeCollection ranges;
public InvalidAcknowledgementFault(UniqueId sequenceID, SequenceRangeCollection ranges)
: base(true, WsrmFeb2005Strings.InvalidAcknowledgement, SR.GetString(SR.InvalidAcknowledgementFaultReason),
SR.GetString(SR.InvalidAcknowledgementReceived), sequenceID, true, false)
{
this.ranges = ranges;
}
public InvalidAcknowledgementFault(FaultCode code, FaultReason reason,
XmlDictionaryReader detailReader, ReliableMessagingVersion reliableMessagingVersion)
: base(code, WsrmFeb2005Strings.InvalidAcknowledgement, reason, true, false)
{
UniqueId sequenceId;
bool final;
WsrmAcknowledgmentInfo.ReadAck(reliableMessagingVersion, detailReader, out sequenceId, out this.ranges,
out final);
this.SequenceID = sequenceId;
while (detailReader.IsStartElement())
{
detailReader.Skip();
}
detailReader.ReadEndElement();
}
protected override void OnWriteDetailContents(XmlDictionaryWriter writer)
{
WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary;
ReliableMessagingVersion reliableMessagingVersion = this.GetReliableMessagingVersion();
XmlDictionaryString wsrmNs = WsrmIndex.GetNamespace(reliableMessagingVersion);
writer.WriteStartElement(wsrmFeb2005Dictionary.SequenceAcknowledgement, wsrmNs);
WsrmAcknowledgmentHeader.WriteAckRanges(writer, reliableMessagingVersion, this.SequenceID, this.ranges);
writer.WriteEndElement();
}
}
sealed class LastMessageNumberExceededFault : WsrmHeaderFault
{
public LastMessageNumberExceededFault(UniqueId sequenceID)
: base(true, WsrmFeb2005Strings.LastMessageNumberExceeded, SR.GetString(SR.LastMessageNumberExceededFaultReason),
SR.GetString(SR.LastMessageNumberExceeded), sequenceID, false, true)
{
}
public LastMessageNumberExceededFault(FaultCode code, FaultReason reason,
XmlDictionaryReader detailReader, ReliableMessagingVersion reliableMessagingVersion)
: base(code, WsrmFeb2005Strings.LastMessageNumberExceeded, reason, detailReader, reliableMessagingVersion, false,
true)
{
}
}
sealed class MessageNumberRolloverFault : WsrmHeaderFault
{
public MessageNumberRolloverFault(UniqueId sequenceID)
: base(true, WsrmFeb2005Strings.MessageNumberRollover, SR.GetString(SR.MessageNumberRolloverFaultReason),
SR.GetString(SR.MessageNumberRollover), sequenceID, true, true)
{
}
public MessageNumberRolloverFault(FaultCode code, FaultReason reason, XmlDictionaryReader detailReader,
ReliableMessagingVersion reliableMessagingVersion)
: base(code, WsrmFeb2005Strings.MessageNumberRollover, reason, true, true)
{
try
{
this.SequenceID = WsrmUtilities.ReadIdentifier(detailReader, reliableMessagingVersion);
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
detailReader.ReadStartElement(DXD.Wsrm11Dictionary.MaxMessageNumber,
WsrmIndex.GetNamespace(reliableMessagingVersion));
string maxMessageNumberString = detailReader.ReadContentAsString();
ulong maxMessageNumber;
if (!UInt64.TryParse(maxMessageNumberString, out maxMessageNumber)
|| (maxMessageNumber <= 0))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(
SR.GetString(SR.InvalidSequenceNumber, maxMessageNumber)));
}
// otherwise ignore value
detailReader.ReadEndElement();
}
}
finally
{
detailReader.Close();
}
}
protected override void OnWriteDetailContents(XmlDictionaryWriter writer)
{
ReliableMessagingVersion reliableMessagingVersion = this.GetReliableMessagingVersion();
WsrmUtilities.WriteIdentifier(writer, reliableMessagingVersion, this.SequenceID);
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
writer.WriteStartElement(WsrmFeb2005Strings.Prefix, DXD.Wsrm11Dictionary.MaxMessageNumber,
WsrmIndex.GetNamespace(reliableMessagingVersion));
writer.WriteValue(Int64.MaxValue);
writer.WriteEndElement();
}
}
}
sealed class SequenceClosedFault : WsrmHeaderFault
{
public SequenceClosedFault(UniqueId sequenceID)
: base(true, Wsrm11Strings.SequenceClosed, SR.GetString(SR.SequenceClosedFaultString),
null, sequenceID, false, true)
{
}
public SequenceClosedFault(FaultCode code, FaultReason reason, XmlDictionaryReader detailReader,
ReliableMessagingVersion reliableMessagingVersion)
: base(code, Wsrm11Strings.SequenceClosed, reason, detailReader, reliableMessagingVersion, false, true)
{
}
}
sealed class SequenceTerminatedFault : WsrmHeaderFault
{
SequenceTerminatedFault(bool isSenderFault, UniqueId sequenceID, string faultReason, string exceptionMessage)
: base(isSenderFault, WsrmFeb2005Strings.SequenceTerminated, faultReason, exceptionMessage, sequenceID, true, true)
{
}
public SequenceTerminatedFault(FaultCode code, FaultReason reason, XmlDictionaryReader detailReader,
ReliableMessagingVersion reliableMessagingVersion)
: base(code, WsrmFeb2005Strings.SequenceTerminated, reason, detailReader, reliableMessagingVersion, true, true)
{
}
public static WsrmFault CreateCommunicationFault(UniqueId sequenceID, string faultReason,
string exceptionMessage)
{
return new SequenceTerminatedFault(false, sequenceID, faultReason, exceptionMessage);
}
public static WsrmFault CreateMaxRetryCountExceededFault(UniqueId sequenceId)
{
return CreateCommunicationFault(sequenceId, SR.GetString(SR.SequenceTerminatedMaximumRetryCountExceeded), null);
}
public static WsrmFault CreateProtocolFault(UniqueId sequenceID, string faultReason,
string exceptionMessage)
{
return new SequenceTerminatedFault(true, sequenceID, faultReason, exceptionMessage);
}
public static WsrmFault CreateQuotaExceededFault(UniqueId sequenceID)
{
return CreateProtocolFault(sequenceID, SR.GetString(SR.SequenceTerminatedQuotaExceededException), null);
}
}
sealed class UnknownSequenceFault : WsrmHeaderFault
{
public UnknownSequenceFault(UniqueId sequenceID)
: base(true, WsrmFeb2005Strings.UnknownSequence, SR.GetString(SR.UnknownSequenceFaultReason),
SR.GetString(SR.UnknownSequenceMessageReceived), sequenceID, true, true)
{
}
public UnknownSequenceFault(FaultCode code, FaultReason reason, XmlDictionaryReader detailReader,
ReliableMessagingVersion reliableMessagingVersion)
: base(code, WsrmFeb2005Strings.UnknownSequence, reason, detailReader, reliableMessagingVersion, true, true)
{
}
public override CommunicationException CreateException()
{
string message;
if (this.IsRemote)
{
message = FaultException.GetSafeReasonText(this.Reason);
message = SR.GetString(SR.UnknownSequenceFaultReceived, message);
}
else
{
message = this.GetExceptionMessage();
}
return new CommunicationException(message);
}
}
class WsrmSequenceFaultHeader : WsrmMessageHeader
{
WsrmFault fault;
public WsrmSequenceFaultHeader(ReliableMessagingVersion reliableMessagingVersion, WsrmFault fault)
: base(reliableMessagingVersion)
{
this.fault = fault;
}
public WsrmFault Fault
{
get
{
return this.fault;
}
}
public override XmlDictionaryString DictionaryName
{
get
{
return XD.WsrmFeb2005Dictionary.SequenceFault;
}
}
public string Subcode
{
get
{
return this.fault.Subcode;
}
}
public static XmlDictionaryReader GetReaderAtDetailContents(string detailName, string detailNamespace,
XmlDictionaryReader headerReader, ReliableMessagingVersion reliableMessagingVersion)
{
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
return GetReaderAtDetailContentsFeb2005(detailName, detailNamespace, headerReader);
}
else
{
return GetReaderAtDetailContents11(detailName, detailNamespace, headerReader);
}
}
public static XmlDictionaryReader GetReaderAtDetailContents11(string detailName, string detailNamespace,
XmlDictionaryReader headerReader)
{
XmlDictionaryString wsrmNs = DXD.Wsrm11Dictionary.Namespace;
headerReader.ReadFullStartElement(XD.WsrmFeb2005Dictionary.SequenceFault, wsrmNs);
headerReader.Skip();
headerReader.ReadFullStartElement(XD.Message12Dictionary.FaultDetail, wsrmNs);
if ((headerReader.NodeType != XmlNodeType.Element)
|| (headerReader.NamespaceURI != detailNamespace)
|| (headerReader.LocalName != detailName))
{
headerReader.Close();
return null;
}
return headerReader;
}
public static XmlDictionaryReader GetReaderAtDetailContentsFeb2005(string detailName, string detailNamespace,
XmlDictionaryReader headerReader)
{
try
{
WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary;
XmlDictionaryString wsrmNs = wsrmFeb2005Dictionary.Namespace;
XmlBuffer buffer = null;
int index = 0;
int depth = headerReader.Depth;
headerReader.ReadFullStartElement(wsrmFeb2005Dictionary.SequenceFault, wsrmNs);
while (headerReader.Depth > depth)
{
if ((headerReader.NodeType == XmlNodeType.Element)
&& (headerReader.NamespaceURI == detailNamespace)
&& (headerReader.LocalName == detailName))
{
if (buffer != null)
{
return null;
}
buffer = new XmlBuffer(int.MaxValue);
try
{
index = buffer.SectionCount;
XmlDictionaryWriter writer = buffer.OpenSection(headerReader.Quotas);
// WriteNode moves the reader to the next sibling.
writer.WriteNode(headerReader, false);
}
finally
{
buffer.CloseSection();
}
}
else
{
if (headerReader.Depth == depth)
break;
headerReader.Read();
}
}
// Ensure at least one detail is found;
if (buffer == null)
{
return null;
}
// Close causes a state change. It moves the buffer from Created to Reading.
buffer.Close();
XmlDictionaryReader detailReader = buffer.GetReader(index);
return detailReader;
}
finally
{
headerReader.Close();
}
}
public static string GetSubcode(XmlDictionaryReader headerReader,
ReliableMessagingVersion reliableMessagingVersion)
{
string subCode = null;
try
{
WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary;
XmlDictionaryString wsrmNs = WsrmIndex.GetNamespace(reliableMessagingVersion);
string ns;
headerReader.ReadStartElement(wsrmFeb2005Dictionary.SequenceFault, wsrmNs);
headerReader.ReadStartElement(wsrmFeb2005Dictionary.FaultCode, wsrmNs);
XmlUtil.ReadContentAsQName(headerReader, out subCode, out ns);
if (ns != WsrmIndex.GetNamespaceString(reliableMessagingVersion))
subCode = null;
headerReader.ReadEndElement();
while (headerReader.IsStartElement())
headerReader.Skip();
headerReader.ReadEndElement();
}
finally
{
headerReader.Close();
}
return subCode;
}
protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion)
{
writer.WriteStartElement(WsrmFeb2005Strings.Prefix, WsrmFeb2005Strings.FaultCode, this.Namespace);
writer.WriteXmlnsAttribute(null, this.Namespace);
writer.WriteQualifiedName(this.Subcode, this.Namespace);
writer.WriteEndElement();
bool wsrm11 = this.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
if (wsrm11)
{
writer.WriteStartElement(WsrmFeb2005Strings.Prefix, XD.Message12Dictionary.FaultDetail, this.DictionaryNamespace);
}
this.fault.WriteDetail(writer);
if (wsrm11)
{
writer.WriteEndElement();
}
}
}
}
|