public static bool ExtractActivityAndCorrelationId(MessageHeaders headers, out Guid activityId, out Guid correlationId)
{
if (headers == null) throw new ArgumentNullException(nameof(headers));
activityId = Guid.Empty;
correlationId = Guid.Empty;
try
{
var index = headers.FindHeader("ActivityId", "http://schemas.microsoft.com/2004/09/ServiceModel/Diagnostics");
if (index >= 0)
{
using (var reader = headers.GetReaderAtHeader(index))
{
correlationId = new Guid(reader.GetAttribute("CorrelationId", null));
activityId = reader.ReadElementContentAsGuid();
return true;
}
}
}
catch
{
if (Debugger.IsAttached)
{
throw;
}
}
return false;
}
public static RequestTotalItemsCountEstimate ReadFrom(MessageHeaders messageHeaders)
{
int index = messageHeaders.FindHeader(ElementName, ManagementNamespaces.Namespace);
if (index < 0)
{
return null;
}
MessageHeaderInfo headerInfo = messageHeaders[index];
return new RequestTotalItemsCountEstimate();
}
/// <summary>
/// Gets the data signature in the given message header collection
/// </summary>
/// <param name="headers">Message headers</param>
/// <returns>Data signature or Guid.Empty</returns>
public static Guid GetDataSignature(MessageHeaders headers)
{
Guid dataSignature = Guid.Empty;
int headerIndex = headers.FindHeader(Header.Name, Header.Namespace);
if (headerIndex != -1)
{
dataSignature = headers.GetHeader<Guid>(headerIndex);
}
return dataSignature;
}
public static bool Remove(MessageHeaders messageHeaders)
{
if (messageHeaders != null)
{
int num = messageHeaders.FindHeader("SystemTracker", "http://schemas.microsoft.com/servicebus/2010/08/protocol/");
if (num >= 0)
{
messageHeaders.RemoveAt(num);
return(true);
}
}
return(false);
}
public static UniqueId GetHeaderUniqueId(MessageHeaders headers, string name, string ns)
{
UniqueId id = null;
int headerIndex = headers.FindHeader(name, ns);
if (headerIndex >= 0)
{
using (XmlDictionaryReader reader = headers.GetReaderAtHeader(headerIndex))
{
id = reader.ReadElementContentAsUniqueId();
}
headers.UnderstoodHeaders.Add(headers[headerIndex]);
}
return id;
}
public static TotalItemsCountEstimate ReadFrom(MessageHeaders messageHeaders)
{
TotalItemsCountEstimate result;
int index = messageHeaders.FindHeader(ElementName, ManagementNamespaces.Namespace);
if (index < 0)
{
return null;
}
using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index))
{
result = ReadFrom(readerAtHeader);
}
return result;
}
public static string GetHeaderString(MessageHeaders headers, string name, string ns)
{
string str = null;
int headerIndex = headers.FindHeader(name, ns);
if (headerIndex >= 0)
{
using (XmlDictionaryReader reader = headers.GetReaderAtHeader(headerIndex))
{
str = reader.ReadElementString();
}
headers.UnderstoodHeaders.Add(headers[headerIndex]);
}
return str;
}
string GetHeaderValue(MessageHeaders headers, string name, string ns)
{
//var headers = OperationContext.Current.IncomingMessageHeaders;
var index = headers.FindHeader(name, ns);
if (index >= 0)
{
return(headers.GetHeader <string>(index));
}
else
{
return(null);
}
}
public static ResourceUriHeader ReadFrom(MessageHeaders messageHeaders)
{
ResourceUriHeader result;
int index = messageHeaders.FindHeader(ElementName, ManagementNamespaces.Namespace);
if (index < 0)
{
return null;
}
using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index))
{
result = ReadFrom(readerAtHeader);
}
return result;
}
public static ResourceUriHeader ReadFrom(MessageHeaders messageHeaders)
{
ResourceUriHeader result;
int index = messageHeaders.FindHeader(ElementName, ManagementNamespaces.Namespace);
if (index < 0)
{
return(null);
}
using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index))
{
result = ReadFrom(readerAtHeader);
}
return(result);
}
public static FragmentTransferHeader ReadFrom(MessageHeaders messageHeaders)
{
FragmentTransferHeader result;
int index = messageHeaders.FindHeader(ElementName, ManagementNamespaces.Namespace);
if (index < 0)
{
return null;
}
using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index))
{
result = ReadFrom(readerAtHeader);
}
MessageHeaderInfo headerInfo = messageHeaders[index];
return result;
}
internal static void Replace(ServiceRemotingMessageHeaders value, MessageHeaders headers)
{
Debug.Assert(value != default(T));
Debug.Assert(headers != null);
int index = headers.FindHeader(typeof(ServiceRemotingMessageHeaders).Name, typeof(ServiceRemotingMessageHeaders).FullName);
if (index >= 0)
{
headers.RemoveAt(index);
}
MessageHeader <ServiceRemotingMessageHeaders> genericHeader = new MessageHeader <ServiceRemotingMessageHeaders>(value);
headers.Add(genericHeader.GetUntypedHeader(typeof(ServiceRemotingMessageHeaders).Name, typeof(ServiceRemotingMessageHeaders).FullName));
}
public CertificateDto RegisterClient(string address)
{
CertificateDto certDto = null;
if (!String.IsNullOrEmpty(address))
{
MessageHeaders headers = OperationContext.Current.RequestContext.RequestMessage.Headers;
string subject = null;
if (headers.FindHeader("UserName", "") > -1)
{
subject = headers.GetHeader <string>(headers.FindHeader("UserName", ""));
}
if (subject == null)
{
throw new Exception("Invalid user name");
}
//string subject = ServiceSecurityContext.Current.PrimaryIdentity.Name.Replace('\\','_').Trim();
//string port = address.Split(':')[2].Split('/')[0];
//subject = subject.Replace('-', '_') + port;
certDto = CAProxy.GenerateCertificate(subject, address);
}
return(certDto);
}
public void DoWork()
{
//check for CustomHeaderValue custom header
MessageHeaders headers = OperationContext.Current.IncomingMessageHeaders;
if (headers.FindHeader("CustomHeaderValue", "ns") != -1)
{
var customheader = headers.GetHeader <string>("CustomHeaderValue", "ns");
if (customheader != null)
{
Helper.Log("ServiceDemo.DoWork() was called with custom header CustomHeaderValue: {0}", customheader);
}
}
//check for InspectorHeader custom header
if (headers.FindHeader("InspectorHeader", "ns") != -1)
{
var customheader = headers.GetHeader <string>("InspectorHeader", "ns");
if (customheader != null)
{
Helper.Log("ServiceDemo.DoWork() was called with header from Inspector InspectorHeader: {0}", customheader);
}
}
}
public static IdentifierHeader ReadFrom(MessageHeaders messageHeaders)
{
IdentifierHeader result;
int index = messageHeaders.FindHeader(ElementName, EventingActions.Namespace);
if (index < 0)
{
return null;
}
using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index))
{
result = ReadFrom(readerAtHeader);
}
MessageHeaderInfo headerInfo = messageHeaders[index];
return result;
}
public static TotalItemsCountEstimate ReadFrom(MessageHeaders messageHeaders)
{
TotalItemsCountEstimate result;
int index = messageHeaders.FindHeader(ElementName, ManagementNamespaces.Namespace);
if (index < 0)
{
return(null);
}
using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index))
{
result = ReadFrom(readerAtHeader);
}
return(result);
}
public void TestFindHeader()
{
// <a:Action mU="true">test</a:Action>
Message m = Message.CreateMessage(MessageVersion.Default, "test", 1);
Assert.AreEqual(1, m.Headers.Count, "#0");
// <MyHeader xmlns="bar">1</MyHeader>
m.Headers.Add(MessageHeader.CreateHeader("MyHeader", "bar", 1));
// <MyHeader xmlns="baz" role="john">1</MyHeader>
m.Headers.Add(MessageHeader.CreateHeader("MyHeader", "baz", 1, false, "john"));
MessageHeaders headers = m.Headers;
// The first header is at 0
Assert.AreEqual(0, headers.FindHeader("Action", wsa1), "#1");
// The return value of FindHeader maps to its places in the headers
Assert.AreEqual(1, headers.FindHeader("MyHeader", "bar"), "#2");
// If a header has actor (role) specified, then it must be provided
Assert.AreEqual(-1, headers.FindHeader("MyHeader", "baz"), "#3");
Assert.AreEqual(2, headers.FindHeader("MyHeader", "baz", "john"), "#4");
}
public static void MessageHeader_MustUnderstand_False()
{
MessageContractHelpers.IMessageContract clientProxy;
MessageContractTypes.RequestBankingData requestData;
MyInspector inspector = MessageContractHelpers.SetupMessageContractTests(out clientProxy, out requestData);
clientProxy.MessageContractRequestReplyWithMessageHeaderNotNecessaryUnderstood(requestData);
MessageHeaders headers = MessageContractHelpers.GetHeaders(inspector);
int index = headers.FindHeader(MessageContractConstants.extraValuesName, MessageContractConstants.extraValuesNamespace);
var header = headers[index];
Assert.True(header != null, "There's no header in the message.");
Assert.False(header.MustUnderstand, "Expected MustUnderstand to be false, but it was true.");
}
public static string ReadHeader(Message message)
{
string str;
MessageHeaders headers = message.Headers;
int num = headers.FindHeader("BodyFormat", "http://schemas.microsoft.com/netservices/2009/05/servicebus/body");
if (num == -1)
{
return(RelayedHttpUtility.FormatStringDefault);
}
using (XmlDictionaryReader readerAtHeader = headers.GetReaderAtHeader(num))
{
str = readerAtHeader.ReadString();
}
return(str);
}
public static string ReadHeader(Message message, string headerName, string defaultValue)
{
string str;
MessageHeaders headers = message.Headers;
int num = headers.FindHeader(headerName, "http://schemas.microsoft.com/netservices/2009/05/servicebus/web");
if (num == -1)
{
return(defaultValue);
}
using (XmlDictionaryReader readerAtHeader = headers.GetReaderAtHeader(num))
{
str = readerAtHeader.ReadString();
}
return(str);
}
internal static PollingDuplexSession FindHeader(MessageHeaders headers)
{
PollingDuplexSession info = null;
try
{
int headerIndex = headers.FindHeader("Duplex", "http://schemas.microsoft.com/2008/04/netduplex");
if (headerIndex != -1)
{
info = ReadHeaderValue(headers.GetReaderAtHeader(headerIndex));
}
}
catch (XmlException)
{
}
return info;
}
public static SelectorSetHeader ReadFrom(MessageHeaders messageHeaders)
{
SelectorSetHeader result;
int index = messageHeaders.FindHeader(ElementName, ManagementNamespaces.Namespace);
if (index < 0)
{
return(null);
}
using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index))
{
result = ReadFrom(readerAtHeader);
}
MessageHeaderInfo headerInfo = messageHeaders[index];
return(result);
}
public static IdentifierHeader ReadFrom(MessageHeaders messageHeaders)
{
IdentifierHeader result;
int index = messageHeaders.FindHeader(ElementName, EventingActions.Namespace);
if (index < 0)
{
return(null);
}
using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index))
{
result = ReadFrom(readerAtHeader);
}
MessageHeaderInfo headerInfo = messageHeaders[index];
return(result);
}
public static void MarkHeaderAsUnderstood(MessageHeaders headers, string localName, string ns)
{
int num = headers.FindHeader(localName, ns);
if (-1 != num)
{
if (!headers.UnderstoodHeaders.Contains(headers[num]))
{
headers.UnderstoodHeaders.Add(headers[num]);
}
return;
}
else
{
return;
}
}
internal static PollingDuplexSession FindHeader(MessageHeaders headers)
{
PollingDuplexSession info = null;
try
{
int headerIndex = headers.FindHeader("Duplex", "http://schemas.microsoft.com/2008/04/netduplex");
if (headerIndex != -1)
{
info = ReadHeaderValue(headers.GetReaderAtHeader(headerIndex));
}
}
catch (XmlException)
{
}
return(info);
}
public static HttpStatusCode ReadHeader(Message message, HttpStatusCode defaultCode)
{
object obj;
MessageHeaders headers = message.Headers;
int num = headers.FindHeader("StatusCode", "http://schemas.microsoft.com/netservices/2009/05/servicebus/statuscode");
if (num != -1)
{
XmlDictionaryReader readerAtHeader = headers.GetReaderAtHeader(num);
return((HttpStatusCode)int.Parse(readerAtHeader.ReadString(), CultureInfo.InvariantCulture));
}
if (!message.Properties.TryGetValue(HttpResponseMessageProperty.Name, out obj))
{
return(defaultCode);
}
return(((HttpResponseMessageProperty)obj).StatusCode);
}
/// <summary>
/// RemoveTIDHeader(): This method will be used to remove TID information
/// from the MessageHeaders collection passed in.
/// </summary>
/// <param name="tid"></param>
/// <param name="headers"></param>
/// <returns></returns>
public static bool RemoveTIDHeader(ITID tid, ref MessageHeaders headers)
{
bool bRemoved = false;
if (tid != null && headers != null)
{
int iHeaderIndex = headers.FindHeader("TID", "TID");
// If we found the header, remove it.
if (iHeaderIndex > -1)
{
headers.RemoveAt(iHeaderIndex);
bRemoved = true;
}
}
return(bRemoved);
}
public static MaxEnvelopeSizeHeader ReadFrom(MessageHeaders messageHeaders)
{
MaxEnvelopeSizeHeader result;
int index = messageHeaders.FindHeader(ElementName, Const.ManagementNamespace);
if (index < 0)
{
return null;
}
using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index))
{
result = ReadFrom(readerAtHeader);
}
MessageHeaderInfo headerInfo = messageHeaders[index];
if (!messageHeaders.UnderstoodHeaders.Contains(headerInfo))
{
messageHeaders.UnderstoodHeaders.Add(headerInfo);
}
return result;
}
/// <summary>
/// Copy message header
/// </summary>
/// <param name="headerName">indicating the name of the header</param>
/// <param name="headerNamespace">indicating the namespace of the header</param>
/// <param name="source">indicating the source message header collection</param>
/// <param name="destination">indicating the destination message header collection</param>
public static void CopyMessageHeader(string headerName, string headerNamespace, MessageHeaders source, MessageHeaders destination)
{
int udIndex = source.FindHeader(headerName, headerNamespace);
if (udIndex >= 0)
{
if (source.MessageVersion == destination.MessageVersion)
{
// If the message version of source and destination matches, directly copy it from the source
destination.CopyHeaderFrom(source, udIndex);
}
else
{
// add request message user data to response message header as an array of XmlNode.
XmlNode[] content = source.GetHeader <XmlNode[]>(udIndex);
destination.Add(MessageHeader.CreateHeader(headerName, headerNamespace, content));
}
}
}
public static bool TryRead(MessageHeaders messageHeaders, out TrackingIdHeader trackingIdHeader)
{
trackingIdHeader = null;
if (messageHeaders == null)
{
return(false);
}
int num = messageHeaders.FindHeader("TrackingId", "http://schemas.microsoft.com/servicebus/2010/08/protocol/");
if (num >= 0)
{
using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(num))
{
readerAtHeader.ReadStartElement();
trackingIdHeader = new TrackingIdHeader(readerAtHeader.ReadString());
}
}
return(trackingIdHeader != null);
}
/// <summary>
/// Will retrieve the custom PARAMETER LIST passed in by the client from
/// the ASABaseMessageContract
/// </summary>
/// <param name="headers"></param>
/// <returns></returns>
public static Dictionary <string, string> GetParamList(MessageHeaders headers)
{
Dictionary <string, string> paramList = null;
if (headers != null)
{
int iHeaderIndex = headers.FindHeader("ParamList", ASA.WCFExtensions.ASABaseRequestContract.PARAMLIST_NAMESPACE);
// If we found the header, remove it.
if (iHeaderIndex > -1)
{
paramList = headers.GetHeader <Dictionary <string, string> >(iHeaderIndex);
//remove paramlist from message headers.. it will get re-added later inside TID.
headers.RemoveAt(iHeaderIndex);
}
}
return(paramList);
}
public static bool TryAddOrUpdate(MessageHeaders messageHeaders, string trackingId)
{
if (messageHeaders == null)
{
return(false);
}
TrackingIdHeader trackingIdHeader = new TrackingIdHeader(trackingId);
int num = messageHeaders.FindHeader("TrackingId", "http://schemas.microsoft.com/servicebus/2010/08/protocol/");
if (num < 0)
{
messageHeaders.Add(trackingIdHeader);
}
else
{
messageHeaders.RemoveAt(num);
messageHeaders.Add(trackingIdHeader);
}
return(true);
}
// Token: 0x06000383 RID: 899 RVA: 0x00015E78 File Offset: 0x00014078
internal static bool HasBinarySecretHeader(out string binarySecretHeader)
{
binarySecretHeader = null;
int num = 0;
MessageHeaders incomingMessageHeaders = OperationContext.Current.IncomingMessageHeaders;
try
{
num = incomingMessageHeaders.FindHeader("BinarySecret", "http://schemas.microsoft.com/exchange/2010/Autodiscover");
}
catch (MessageHeaderException)
{
return(false);
}
if (num < 0)
{
return(false);
}
binarySecretHeader = incomingMessageHeaders.GetHeader <string>(num);
return(true);
}
internal static ServiceRemotingMessageHeaders Get(MessageHeaders headers)
{
Debug.Assert(headers != null);
try
{
if (headers.FindHeader(typeof(ServiceRemotingMessageHeaders).Name, typeof(ServiceRemotingMessageHeaders).FullName) < 0)
{
return(new ServiceRemotingMessageHeaders());
}
else
{
return(headers.GetHeader <ServiceRemotingMessageHeaders>(typeof(ServiceRemotingMessageHeaders).Name, typeof(ServiceRemotingMessageHeaders).FullName));
}
}
catch (Exception exception)
{
Debug.Assert(IsHeaderNotExistsException(exception));
return(null);
}
}
public static SelectorSetHeader ReadFrom(MessageHeaders messageHeaders)
{
SelectorSetHeader result;
int index = messageHeaders.FindHeader(ElementName, Const.ManagementNamespace);
if (index < 0)
{
return(null);
}
using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index))
{
result = ReadFrom(readerAtHeader);
}
MessageHeaderInfo headerInfo = messageHeaders[index];
if (!messageHeaders.UnderstoodHeaders.Contains(headerInfo))
{
messageHeaders.UnderstoodHeaders.Add(headerInfo);
}
return(result);
}
protected T GetMessageHeaderData <T>(ref System.ServiceModel.Channels.Message message,
OperationContext context,
string headerNamespace, string headerName)
where T : class
{
ModuleProc PROC = new ModuleProc(this.DYN_MODULE_NAME, "GetMessageHeaderData");
T result = default(T);
try
{
if (message != null)
{
if (!headerNamespace.IsEmpty() &&
!headerName.IsEmpty())
{
if (context != null &&
context.IncomingMessageHeaders != null)
{
MessageHeaders headers = context.IncomingMessageHeaders;
int index = headers.FindHeader(headerName, headerNamespace);
if (index != -1)
{
result = DeserializeDC <T>(headers.GetReaderAtHeader(index));
headers.RemoveAt(index);
}
}
}
}
}
catch (Exception ex)
{
Log.Exception(PROC, ex);
}
return(result);
}
/// <summary>
/// Adds the message header.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="name">The name.</param>
/// <param name="ns">The ns.</param>
/// <param name="createHeader">The create header.</param>
protected virtual MessageHeader AddMessageHeader(ref System.ServiceModel.Channels.Message request,
string name, string ns, Func <MessageHeader> createHeader)
{
ModuleProc PROC = new ModuleProc(this.DYN_MODULE_NAME, "AddMessageHeader");
MessageHeader result = null;
try
{
MessageHeaders headers = request.Headers;
if (headers != null)
{
if (headers.FindHeader(name, ns) == -1)
{
headers.Add((result = createHeader()));
}
}
}
catch (Exception ex)
{
Log.Exception(PROC, ex);
}
return(result);
}
//This method will try to retrieve a header whose value matches the GUID passed by the client.
//The return value will notify the client whether the service was able to retrieve the header or not.
public bool RetrieveHeader(string guid)
{
MessageHeaders messageHeaderCollection = OperationContext.Current.IncomingMessageHeaders;
String guidHeader = null;
Console.WriteLine("Trying to check if IncomingMessageHeader collection contains header with value {0}", guid);
if (messageHeaderCollection.FindHeader(CustomHeader.HeaderName, CustomHeader.HeaderNamespace) != -1)
{
guidHeader = messageHeaderCollection.GetHeader <String>(CustomHeader.HeaderName, CustomHeader.HeaderNamespace);
}
else
{
Console.WriteLine("No header was found");
}
if (guidHeader != null)
{
Console.WriteLine("Found header with value {0}. Does it match with GUID sent as parameter: {1}", guidHeader, guidHeader.Equals(guid));
}
Console.WriteLine();
//Return true if header is present and equals the guid sent by client as argument
return(guidHeader != null && guidHeader.Equals(guid));
}
public static void MarkHeaderAsUnderstood(MessageHeaders headers, string localName, string ns)
{
int num = headers.FindHeader(localName, ns);
if (-1 != num)
{
if (!headers.UnderstoodHeaders.Contains(headers[num]))
{
headers.UnderstoodHeaders.Add(headers[num]);
}
return;
}
else
{
return;
}
}
/// <summary>
/// 删除消息头
/// </summary>
/// <param name="headers"></param>
/// <param name="index"></param>
internal static void RemoveHeader(MessageHeaders headers)
{
if (headers.FindHeader("HeaderContext", "session") >= 0)
headers.RemoveAt(headers.FindHeader("HeaderContext", "session"));
}
/// <summary>
/// 删除消息头
/// </summary>
/// <param name="headers"></param>
/// <param name="index"></param>
internal static void RemoveAppNameHeader(MessageHeaders headers)
{
if (headers.FindHeader("AppNameHeaderContext", "appnamesession") >= 0)
headers.RemoveAt(headers.FindHeader("AppNameHeaderContext", "appnamesession"));
}
public static bool Exists(MessageHeaders headers)
{
return(headers.FindHeader(GenericContext <InitializingContext> .TypeName, GenericContext <InitializingContext> .TypeNamespace) >= 0);
}
public void BeforeSendRequestTest()
{
// Arrange.
const string HeaderName1 = "Header1";
const string HeaderName2 = "Header2";
const string HeaderNamespace = "TestNamespace";
const string Actor = "TestActor";
var oldHeader1 = MessageHeader.CreateHeader(HeaderName1, HeaderNamespace, "Test Value 1");
var oldHeader2 = MessageHeader.CreateHeader(HeaderName2, HeaderNamespace, "Test Value 2");
var operationContext = Mock.Create<OperationContext>();
Mock.Arrange(() => OperationContext.Current).Returns(operationContext);
var headerAttributes = new SoapHeaderAttributes
{
HeaderName = HeaderName2,
HeaderNamespace = HeaderNamespace,
MustUnderstand = true,
Actor = Actor,
Relay = true
};
var integrationExtension = new IntegrationServiceOperationContextExtension();
integrationExtension.HeaderAttributes.Add(headerAttributes);
var extensions = new ExtensionCollection<OperationContext>(operationContext) { integrationExtension };
Mock.Arrange(() => operationContext.Extensions).Returns(extensions);
var message = Mock.Create<Message>();
var messageHeaders = new MessageHeaders(MessageVersion.Soap11) { oldHeader1, oldHeader2 };
Mock.Arrange(() => message.Headers).Returns(messageHeaders);
var inspector = new IntegrationServiceMessageInspector();
// Act.
var newMessage = message;
inspector.BeforeSendRequest(ref newMessage, Mock.Create<IClientChannel>());
// Assert.
Assert.AreSame(message, newMessage);
Assert.AreEqual(2, messageHeaders.Count);
Assert.IsTrue(messageHeaders.Contains(oldHeader1));
Assert.IsFalse(messageHeaders.Contains(oldHeader2));
var index = messageHeaders.FindHeader(HeaderName2, HeaderNamespace, Actor);
var newHeader2 = (XmlElementMessageHeader)messageHeaders[index];
Assert.IsTrue(newHeader2.MustUnderstand);
Assert.AreEqual(Actor, newHeader2.Actor);
Assert.IsTrue(newHeader2.Relay);
// Exceptions.
Message nullMessage = null;
TestsHelper.VerifyThrow<ArgumentNullException>(() => inspector.BeforeSendRequest(ref nullMessage, Mock.Create<IClientChannel>()));
var message2 = Mock.Create<Message>();
TestsHelper.VerifyThrow<ArgumentNullException>(() => inspector.BeforeSendRequest(ref message2, null));
}