public void AddDuplicate2()
{
MessageHeaders headers = new MessageHeaders(MessageVersion.Default);
headers.Add(MessageHeader.CreateHeader("Action", wsa1, "urn:foo", true, "whoa"));
headers.Add(MessageHeader.CreateHeader("Action", wsa1, "urn:bar", true, "whee"));
}
public void DuplicateActionFindError()
{
MessageHeaders headers = new MessageHeaders(MessageVersion.Default);
headers.Add(MessageHeader.CreateHeader("Action", wsa1, "urn:foo"));
headers.Add(MessageHeader.CreateHeader("Action", wsa1, "urn:bar"));
Assert.Fail(String.Format("Action should not be caught", headers.Action)); // access to Action results in an error. If it does not, then simply assert fail.
}
public void UpdateHeader(MessageHeaders headers)
{
FaultInjectionInfo.RemoveHeader(headers);
MessageHeader messageHeader = MessageHeader.CreateHeader("FaultInjectionInfo", "http://schemas.microsoft.com/netservices/2011/06/servicebus", this, FaultInjectionInfo.serializer);
headers.Add(messageHeader);
}
public static void Add(MessageHeaders headers)
{
GenericContext <InitializingContext> context = new GenericContext <InitializingContext>(new InitializingContext());
MessageHeader <GenericContext <InitializingContext> > genericHeader = new MessageHeader <GenericContext <InitializingContext> >(context);
headers.Add(genericHeader.GetUntypedHeader(GenericContext <InitializingContext> .TypeName, GenericContext <InitializingContext> .TypeNamespace));
}
public void AddHeaders(MessageHeaders headers)
{
if (headers.MessageVersion.Envelope == EnvelopeVersion.Soap11)
{
headers.Add(new WSAddressing10ProblemHeaderQNameHeader(this.invalidHeaderName));
}
}
public void AddHeaders(MessageHeaders headers)
{
if (headers.MessageVersion.Envelope == EnvelopeVersion.Soap11)
{
headers.Add(new WSAddressing10ProblemHeaderQNameHeader(_invalidHeaderName));
}
}
public static void Add(MessageHeaders headers, ActorId actorId)
{
GenericContext <ActorId> context = new GenericContext <ActorId>(actorId);
MessageHeader <GenericContext <ActorId> > genericHeader = new MessageHeader <GenericContext <ActorId> >(context);
headers.Add(genericHeader.GetUntypedHeader(GenericContext <ActorId> .TypeName, GenericContext <ActorId> .TypeNamespace));
}
public static void AddHeader <T>(this MessageHeaders headers, string name, T value)
{
if (headers == null)
{
throw new InvalidOperationException("No headers could be found in the OperationContext, or the OperationContext does not exist.");
}
bool headerExists = false;
try
{
var existingHeader = headers.GetHeader <T>(Header <T> .GetFullName(name),
Header <T> .TypeNamespace);
if (existingHeader != null)
{
headerExists = true;
}
}
catch (MessageHeaderException)
{
// Debug.Assert(IsHeaderNotExistsException(exception));
}
if (headerExists)
{
throw new InvalidOperationException("A header with name " + Header <T> .GetFullName(name) + " and namespace " + Header <T> .TypeNamespace + " already exists in the message.");
}
MessageHeader <Header <T> > genericHeader = new MessageHeader <Header <T> >(new Header <T>(value));
headers.Add(genericHeader.GetUntypedHeader(Header <T> .GetFullName(name), Header <T> .TypeNamespace));
}
void AddNotUnderstoodHeaders(MessageHeaders headers)
{
for (int i = 0; i < notUnderstoodHeaders.Count; ++i)
{
headers.Add(new NotUnderstoodHeader(notUnderstoodHeaders[i].Name, notUnderstoodHeaders[i].Namespace));
}
}
private void AddNotUnderstoodHeaders(MessageHeaders headers)
{
for (int i = 0; i < _notUnderstoodHeaders.Count; ++i)
{
headers.Add(new NotUnderstoodHeader(_notUnderstoodHeaders[i].Name, _notUnderstoodHeaders[i].Namespace));
}
}
public static void Add(MessageHeaders headers, ServiceContext serviceContext)
{
GenericContext <ServiceContext> context = new GenericContext <ServiceContext>(serviceContext);
MessageHeader <GenericContext <ServiceContext> > genericHeader = new MessageHeader <GenericContext <ServiceContext> >(context);
headers.Add(genericHeader.GetUntypedHeader(GenericContext <ServiceContext> .TypeName, GenericContext <ServiceContext> .TypeNamespace));
}
void CloneHeaders(MessageHeaders targetHeaders, MessageHeaders sourceHeaders, Uri to, HashSet <string> understoodHeadersSet)
{
for (int i = 0; i < sourceHeaders.Count; ++i)
{
MessageHeaderInfo header = sourceHeaders[i];
if (!understoodHeadersSet.Contains(MessageHeaderKey(header)))
{
//If Actor is SOAP Intermediary ("*actor/next" which is us) check the Relay flag
if (!ActorIsNextDestination(header, sourceHeaders.MessageVersion) || header.Relay)
{
//Always wrap the header because BufferedHeader isn't smart enough to allow custom
//headers to switch message versions
MessageHeader messageHeader = new DelegatingHeader(header, sourceHeaders);
targetHeaders.Add(messageHeader);
}
}
}
// To and Action (already specified) are 'special' and may be set even with AddressingVersion.None
targetHeaders.To = to;
if (targetHeaders.MessageVersion.Addressing != AddressingVersion.None)
{
//These are used as correlation IDs. Copy these regardless of manual addressing.
targetHeaders.MessageId = sourceHeaders.MessageId;
targetHeaders.RelatesTo = sourceHeaders.RelatesTo;
if (this.manualAddressing)
{
//These are addresses, only copy when ManualAddressing is enabled
targetHeaders.FaultTo = sourceHeaders.FaultTo;
targetHeaders.ReplyTo = sourceHeaders.ReplyTo;
targetHeaders.From = sourceHeaders.From;
}
}
}
private void AddNotUnderstoodHeaders(MessageHeaders headers)
{
for (int i = 0; i < this.notUnderstoodHeaders.Count; i++)
{
headers.Add(new NotUnderstoodHeader(this.notUnderstoodHeaders[i].Name, this.notUnderstoodHeaders[i].Namespace));
}
}
private void CreateBackgroundTask()
{
consumer = this.consumerBuilder.Build();
this.consumerManager.AddOrUpdate(new MessageConsumer(this, this.workerPool, this.configuration, this.logHandler));
consumer.Subscribe(this.configuration.Topics);
this.backgroundTask = Task.Factory.StartNew(
async() =>
{
using (consumer)
{
while (!this.stopCancellationTokenSource.Token.IsCancellationRequested)
{
try
{
var message = consumer.Consume(this.stopCancellationTokenSource.Token);
var headers = new MessageHeaders();
foreach (var header in message.Message.Headers)
{
headers.Add(header.Key, header.GetValueBytes());
}
var intermediateMessage = new IntermediateMessage(headers, message.Message.Value);
intermediateMessage.Topic = message.Topic;
intermediateMessage.Partition = message.Partition;
intermediateMessage.Offset = message.Offset;
await this.workerPool.EnqueueAsync(intermediateMessage, this.stopCancellationTokenSource.Token).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
// Ignores the exception
}
catch (KafkaException ex) when(ex.Error.IsFatal)
{
this.logHandler.Error("Kafka fatal error occurred. Trying to restart in 5 seconds", ex, null);
await this.workerPool.StopAsync().ConfigureAwait(false);
_ = Task
.Delay(5000, this.stopCancellationTokenSource.Token)
.ContinueWith(t => this.CreateBackgroundTask());
break;
}
catch (Exception ex)
{
this.logHandler.Warning("Error consuming message from Kafka", ex);
}
}
consumer.Close();
}
},
CancellationToken.None,
TaskCreationOptions.LongRunning,
TaskScheduler.Default);
}
public void GetHeaderNullSerializer2()
{
MessageHeaders headers = new MessageHeaders(MessageVersion.Default);
string ns = "http://schemas.xmlsoap.org/ws/2004/08/addressing";
headers.Add(MessageHeader.CreateHeader("Action", ns, "urn:foo"));
headers.GetHeader <string> ("Action", ns, (XmlObjectSerializer)null);
}
/// <summary>
/// Create response headers
/// </summary>
private System.ServiceModel.Channels.MessageHeaders CreateResponseHeaders(XmlNodeList xmlNodeList, MessageVersion ver)
{
if (xmlNodeList == null)
{
return(null);
}
MessageHeaders retVal = new MessageHeaders(ver);
foreach (XmlElement hdr in xmlNodeList)
{
if (hdr.NamespaceURI == "http://schemas.xmlsoap.org/ws/2004/08/addressing" || hdr.NamespaceURI == "http://www.w3.org/2005/08/addressing")
{
switch (hdr.LocalName)
{
case "Action":
retVal.Action = hdr.InnerText;
break;
case "To":
retVal.To = new Uri(hdr.InnerText);
break;
case "From":
retVal.From = new System.ServiceModel.EndpointAddress(hdr.InnerText);
break;
case "ReplyTo":
retVal.ReplyTo = new System.ServiceModel.EndpointAddress(hdr.InnerText);
break;
default:
MessageHeader header = MessageHeader.CreateHeader(hdr.LocalName, hdr.NamespaceURI, hdr.InnerText);
retVal.Add(header);
break;
}
}
else
{
MessageHeader header = MessageHeader.CreateHeader(hdr.LocalName, hdr.NamespaceURI, hdr.InnerText);
retVal.Add(header);
}
}
return(retVal);
}
private void AddMessageHeaderForParameter(MessageHeaders headers, PartInfo headerPart, MessageVersion messageVersion, object parameterValue, bool isXmlElement)
{
MessageHeaderDescription headerDescription = (MessageHeaderDescription)headerPart.Description;
object valueToSerialize = GetContentOfMessageHeaderOfT(headerDescription, parameterValue, out bool mustUnderstand, out bool relay, out string actor);
if (isXmlElement)
{
if (valueToSerialize == null)
{
return;
}
XmlElement xmlElement = (XmlElement)valueToSerialize;
headers.Add(new XmlElementMessageHeader(this, messageVersion, xmlElement.LocalName, xmlElement.NamespaceURI, mustUnderstand, actor, relay, xmlElement));
return;
}
headers.Add(new DataContractSerializerMessageHeader(headerPart, valueToSerialize, mustUnderstand, actor, relay));
}
public ValidatingContext(TMessage message)
{
Guard.AgainstNull(message, nameof(message));
this.message = message;
var value = DateTime.UtcNow.ToUniversalTime().ToString("yyyy-MM-dd HH:mm:ss:ffffff Z", CultureInfo.InvariantCulture);
MessageHeaders.Add(NServiceBus.Headers.TimeSent, value);
Headers.Add(NServiceBus.Headers.TimeSent, value);
}
/// <summary>
/// 设置登录信息
/// </summary>
/// <param name="loginInfo">登录信息</param>
public void SetLoginInfo(LoginInfo loginInfo)
{
if (OperationContext.Current != null)
{
MessageHeader header = MessageHeader.CreateHeader(CommonConstants.WCFAuthenticationHeader, GlobalSetting.ApplicationId, loginInfo.PublicKey);
MessageHeaders headers = OperationContext.Current.IncomingMessageHeaders;
headers.Add(header);
}
}
public void CopyHeadersFrom_Merge()
{
var h1 = new MessageHeaders(MessageVersion.Default);
var h2 = new MessageHeaders(MessageVersion.Default);
h1.Add(MessageHeader.CreateHeader("Action", wsa1, "urn:foo"));
h2.Add(MessageHeader.CreateHeader("Action", wsa1, "urn:bar"));
h1.CopyHeadersFrom(h2); // it somehow allow dups!
Assert.Fail(String.Format("Action should not be caught", h1.Action)); // access to Action results in an error. If it does not, then simply assert fail.
}
public static void AddTo(MessageHeaders messageHeaders, string workUnitName, string workUnitId, int sequenceNumber)
{
WorkUnitInfo workUnitInfo = new WorkUnitInfo()
{
Identifier = workUnitId,
SequenceNumber = sequenceNumber
};
messageHeaders.Add(MessageHeader.CreateHeader(workUnitName, "http://schemas.microsoft.com/netservices/2011/06/servicebus", workUnitInfo));
}
public async Task <ICtsResponse> GetCtsResponseAsync()
{
PfWebConsultaNovedadEnvioMailClient client = new PfWebConsultaNovedadEnvioMailClient();
EndpointAddress endpoint = new EndpointAddress("http://172.28.195.215:9080/COBISCorp.eCOBIS.PfWebConsultaNovedadEnvioMail.Service/PfWebConsultaNovedadEnvioMailWSService");
client = new PfWebConsultaNovedadEnvioMailClient(PfWebConsultaNovedadEnvioMailClient.EndpointConfiguration.PfWebConsultaNovedadEnvioMailWSPort, endpoint);
PfWebConsultaNovedadEnvioMailResponse response;
using (var scope = new FlowingOperationContextScope(client.InnerChannel))
{
// Add a SOAP Header to an outgoing request
MessageHeaders messageHeadersElement = OperationContext.Current.OutgoingMessageHeaders;
messageHeadersElement.Add(new Security()
{
UsernameToken = new UsernameToken()
{
Username = "******",
Password = ""
}
});
RequestConnection requestConnection = new RequestConnection
{
user = "******",
applicationID = "1"
};
Fil fil = new Fil
{
inPfWebConsultaNovedadEnvioMailFil = new PfWebConsultaNovedadEnvioMailFil
{
isSiguiente = 0
}
};
PfWebConsultaNovedadEnvioMailRequest request = new PfWebConsultaNovedadEnvioMailRequest()
{
requestConnection = requestConnection,
fil = fil
};
//response = client.PfWebConsultaNovedadEnvioMailAsync(request, fil).GetAwaiter().GetResult();
//response = await client.PfWebConsultaNovedadEnvioMailAsync(request, fil).ContinueOnScope(scope);
response = await client.PfWebConsultaNovedadEnvioMailAsync(request).ContinueOnScope(scope);
//response = client.PfWebConsultaNovedadEnvioMailAsync(request).GetAwaiter().GetResult();
}
parser = new MailNewsParser(response.executeResponse);
ICtsResponse ctsResponse = new MailNewsResponse();
return(ctsResponse);
}
public static void Update(MessageHeaders headers, ActorId actorId)
{
int index = headers.FindHeader(GenericContext <ActorId> .TypeName, GenericContext <ActorId> .TypeNamespace);
if (index > 0)
{
headers.RemoveAt(index);
MessageHeader <GenericContext <ActorId> > genericHeader = new MessageHeader <GenericContext <ActorId> >(new GenericContext <ActorId>(actorId));
headers.Add(genericHeader.GetUntypedHeader(GenericContext <ActorId> .TypeName, GenericContext <ActorId> .TypeNamespace));
}
}
public static void Update(MessageHeaders headers, ServiceContext context)
{
int index = headers.FindHeader(GenericContext <ServiceContext> .TypeName, GenericContext <ServiceContext> .TypeNamespace);
if (index > 0)
{
headers.RemoveAt(index);
MessageHeader <GenericContext <ServiceContext> > genericHeader = new MessageHeader <GenericContext <ServiceContext> >(new GenericContext <ServiceContext>(context));
headers.Add(genericHeader.GetUntypedHeader(GenericContext <ServiceContext> .TypeName, GenericContext <ServiceContext> .TypeNamespace));
}
}
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);
}
public void Add_WithKeyNotNull_ShouldAddValueCorrectly()
{
// Arrange
var header = new MessageHeaders();
// Act
header.Add(key, this.value);
// Assert
header[key].Should().BeEquivalentTo(this.value);
}
private void AddMessageHeaderForParameter(MessageHeaders headers, PartInfo headerPart, MessageVersion messageVersion, object parameterValue, bool isXmlElement)
{
string str;
bool flag;
bool flag2;
MessageHeaderDescription headerDescription = (MessageHeaderDescription)headerPart.Description;
object headerValue = OperationFormatter.GetContentOfMessageHeaderOfT(headerDescription, parameterValue, out flag, out flag2, out str);
if (isXmlElement)
{
if (headerValue != null)
{
XmlElement element = (XmlElement)headerValue;
headers.Add(new OperationFormatter.XmlElementMessageHeader(this, messageVersion, element.LocalName, element.NamespaceURI, flag, str, flag2, element));
}
}
else
{
headers.Add(new DataContractSerializerMessageHeader(headerPart, headerValue, flag, str, flag2));
}
}
/// <summary>
/// Adds the value of the context to the current outgoing message headers.
/// </summary>
/// <param name="headers">The headers collection.</param>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="headers"/> is <see langword="null"/></exception>
public void AddToHeaders(
MessageHeaders headers)
{
if (headers == null)
{
throw new ArgumentNullException(nameof(headers));
}
headers.Add(
new MessageHeader <CustomDataContext <T> >(this)
.GetUntypedHeader(Name, Namespace));
}
private void CopyMessageHeader(MessageHeaders messageHeaders, int index)
{
try
{
MessageHeaderInfo headerInfo = messageHeaders[index];
XmlQualifiedName qName = new XmlQualifiedName(headerInfo.Name, headerInfo.Namespace);
string headerValue = messageHeaders.GetHeader <string>(index);
MessageHeader header = MessageHeader.CreateHeader(headerInfo.Name, headerInfo.Namespace, headerValue);
MessageHeaders.Add(qName, header);
}
catch (Exception)
{
//eats away headers not of the right type
}
}
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 static void AddMessageHeader(MessageHeaders headers, HeaderParameter para)
{
headers.RemoveAll("CMD", ns);
headers.RemoveAll("RouterID", ns);
headers.RemoveAll("Plugin", ns);
headers.RemoveAll("ReplyIdentify", ns);
headers.RemoveAll("Token", ns);
headers.RemoveAll("IsCompressJson", ns);
headers.RemoveAll("IsEncryptionJson", ns);
headers.RemoveAll("SerializeType", ns);
headers.RemoveAll("LoginRight", ns);
var CMD = System.ServiceModel.Channels.MessageHeader.CreateHeader("CMD", ns, para.cmd);
headers.Add(CMD);
var router = System.ServiceModel.Channels.MessageHeader.CreateHeader("RouterID", ns, para.routerid);
headers.Add(router);
var plugin = System.ServiceModel.Channels.MessageHeader.CreateHeader("Plugin", ns, para.pluginname);
headers.Add(plugin);
var ReplyHN = System.ServiceModel.Channels.MessageHeader.CreateHeader("ReplyIdentify", ns, para.replyidentify);
headers.Add(ReplyHN);
var token = System.ServiceModel.Channels.MessageHeader.CreateHeader("Token", ns, para.token);
headers.Add(token);
var IsCompressJson = System.ServiceModel.Channels.MessageHeader.CreateHeader("IsCompressJson", ns, Convert.ToString(para.iscompressjson ? 1 : 0));
headers.Add(IsCompressJson);
var IsEncryptionJson = System.ServiceModel.Channels.MessageHeader.CreateHeader("IsEncryptionJson", ns, Convert.ToString(para.isencryptionjson ? 1 : 0));
headers.Add(IsEncryptionJson);
var SerializeType = System.ServiceModel.Channels.MessageHeader.CreateHeader("SerializeType", ns, Convert.ToString((int)para.serializetype));
headers.Add(SerializeType);
var LoginRight = System.ServiceModel.Channels.MessageHeader.CreateHeader("LoginRight", ns, para.LoginRight);
headers.Add(LoginRight);
}
private Message CreateWcfMessageInternal(string action, object body, bool includeToken, string parentLinkId, RetryPolicy policy, TrackingContext trackingContext, RequestInfo requestInfo)
{
Message message = Message.CreateMessage(this.messageVersion, action, body);
MessageHeaders headers = message.Headers;
headers.To = this.targetAddress.Uri;
string sufficientClaims = this.GetSufficientClaims();
if (this.linkInfo != null)
{
if (!string.IsNullOrEmpty(this.linkInfo.TransferDestinationEntityAddress))
{
SecurityToken authorizationToken = this.GetAuthorizationToken(this.linkInfo.TransferDestinationEntityAddress, sufficientClaims);
if (authorizationToken != null)
{
SimpleWebSecurityToken simpleWebSecurityToken = (SimpleWebSecurityToken)authorizationToken;
if (simpleWebSecurityToken != null)
{
this.linkInfo.TransferDestinationAuthorizationToken = simpleWebSecurityToken.Token;
}
}
}
this.linkInfo.AddTo(headers);
}
if (includeToken)
{
ServiceBusAuthorizationHeader authorizationHeader = this.GetAuthorizationHeader(sufficientClaims);
if (authorizationHeader != null)
{
headers.Add(authorizationHeader);
}
}
if (this.messagingFactory.FaultInjectionInfo != null)
{
this.messagingFactory.FaultInjectionInfo.AddToHeader(message);
}
if (!string.IsNullOrWhiteSpace(parentLinkId))
{
message.Properties["ParentLinkId"] = parentLinkId;
}
if (trackingContext != null)
{
TrackingIdHeader.TryAddOrUpdate(headers, trackingContext.TrackingId);
}
message.AddHeaderIfNotNull <RequestInfo>("RequestInfo", "http://schemas.microsoft.com/netservices/2011/06/servicebus", requestInfo);
return(message);
}
/// <summary>
/// AddTIDHeader(): This method will be used to add TID information to the
/// MessageHeaders collection passed in. (If a TID already exists in the headers collection,
/// this method will remove it, and replace it with the TID data being passed.)
/// </summary>
/// <param name="tid"></param>
/// <param name="headers"></param>
/// <returns></returns>
public static bool AddTIDHeader(ITID tid, ref MessageHeaders headers)
{
bool bAdded = false;
if (headers != null && tid != null)
{
//this will remove 'tid' from the header if its already in there.. we don't want it added twice.
RemoveTIDHeader(tid, ref headers);
MessageHeader <TIDBase> mhMessageTID = new MessageHeader <TIDBase>((TIDBase)tid);
headers.Add(mhMessageTID.GetUntypedHeader("TID", "TID"));
bAdded = true;
}
return(bAdded);
}
public void TestAddKeyValuePairMethod()
{
MessageHeaders messageHeaders = new MessageHeaders(null);
messageHeaders.Add(new KeyValuePair<string, object>("foo", "bar"));
}
public void GetHeaderNullSerializer2 ()
{
MessageHeaders headers = new MessageHeaders (MessageVersion.Default);
string ns = "http://schemas.xmlsoap.org/ws/2004/08/addressing";
headers.Add (MessageHeader.CreateHeader ("Action", ns, "urn:foo"));
headers.GetHeader<string> ("Action", ns, (XmlObjectSerializer) null);
}
public void TestAction ()
{
Message m = Message.CreateMessage (MessageVersion.Default, "test", 1);
m.Headers.Add (MessageHeader.CreateHeader ("FirstHeader", "ns", "first"));
Assert.AreEqual ("test", m.Headers.Action, "#1");
MessageHeaders headers = new MessageHeaders (MessageVersion.Default, 1);
Assert.AreEqual (null, headers.Action, "#2");
headers.Add (MessageHeader.CreateHeader ("Action", "http://www.w3.org/2005/08/addressing", "test"));
MessageHeaderInfo info = headers [0];
Assert.AreEqual ("Action", info.Name, "#2-1");
Assert.AreEqual ("http://www.w3.org/2005/08/addressing", info.Namespace, "#2-2");
Assert.AreEqual (false, info.MustUnderstand, "#2-3");
Assert.AreEqual (String.Empty, info.Actor, "#2-4");
Assert.AreEqual ("test", headers.Action, "#3");
headers.Clear ();
Assert.AreEqual (null, headers.Action, "#4");
}
public void AddDuplicate2 ()
{
MessageHeaders headers = new MessageHeaders (MessageVersion.Default);
headers.Add (MessageHeader.CreateHeader ("Action", wsa1, "urn:foo", true, "whoa"));
headers.Add (MessageHeader.CreateHeader ("Action", wsa1, "urn:bar", true, "whee"));
}
public void DuplicateActionFindError ()
{
MessageHeaders headers = new MessageHeaders (MessageVersion.Default);
headers.Add (MessageHeader.CreateHeader ("Action", wsa1, "urn:foo"));
headers.Add (MessageHeader.CreateHeader ("Action", wsa1, "urn:bar"));
Assert.Fail (String.Format ("Action should not be caught", headers.Action)); // access to Action results in an error. If it does not, then simply assert fail.
}
public void CopyHeadersFrom_Merge ()
{
var h1 = new MessageHeaders (MessageVersion.Default);
var h2 = new MessageHeaders (MessageVersion.Default);
h1.Add (MessageHeader.CreateHeader ("Action", wsa1, "urn:foo"));
h2.Add (MessageHeader.CreateHeader ("Action", wsa1, "urn:bar"));
h1.CopyHeadersFrom (h2); // it somehow allow dups!
Assert.Fail (String.Format ("Action should not be caught", h1.Action)); // access to Action results in an error. If it does not, then simply assert fail.
}
private void AddMessageHeaderForParameter(MessageHeaders headers, PartInfo headerPart, MessageVersion messageVersion, object parameterValue, bool isXmlElement)
{
string actor;
bool mustUnderstand;
bool relay;
MessageHeaderDescription headerDescription = (MessageHeaderDescription)headerPart.Description;
object valueToSerialize = GetContentOfMessageHeaderOfT(headerDescription, parameterValue, out mustUnderstand, out relay, out actor);
if (isXmlElement)
{
if (valueToSerialize == null)
return;
XmlElement xmlElement = (XmlElement)valueToSerialize;
headers.Add(new XmlElementMessageHeader(this, messageVersion, xmlElement.LocalName, xmlElement.NamespaceURI, mustUnderstand, actor, relay, xmlElement));
return;
}
headers.Add(new DataContractSerializerMessageHeader(headerPart, valueToSerialize, mustUnderstand, actor, relay));
}
private void AddMessageHeaderForParameter(MessageHeaders headers, PartInfo headerPart, MessageVersion messageVersion, object parameterValue, bool isXmlElement)
{
string str;
bool flag;
bool flag2;
MessageHeaderDescription headerDescription = (MessageHeaderDescription) headerPart.Description;
object headerValue = OperationFormatter.GetContentOfMessageHeaderOfT(headerDescription, parameterValue, out flag, out flag2, out str);
if (isXmlElement)
{
if (headerValue != null)
{
XmlElement element = (XmlElement) headerValue;
headers.Add(new OperationFormatter.XmlElementMessageHeader(this, messageVersion, element.LocalName, element.NamespaceURI, flag, str, flag2, element));
}
}
else
{
headers.Add(new DataContractSerializerMessageHeader(headerPart, headerValue, flag, str, flag2));
}
}
void CloneHeaders(MessageHeaders targetHeaders, MessageHeaders sourceHeaders, Uri to, HashSet<string> understoodHeadersSet)
{
for (int i = 0; i < sourceHeaders.Count; ++i)
{
MessageHeaderInfo header = sourceHeaders[i];
if (!understoodHeadersSet.Contains(MessageHeaderKey(header)))
{
//If Actor is SOAP Intermediary ("*actor/next" which is us) check the Relay flag
if (!ActorIsNextDestination(header, sourceHeaders.MessageVersion) || header.Relay)
{
//Always wrap the header because BufferedHeader isn't smart enough to allow custom
//headers to switch message versions
MessageHeader messageHeader = new DelegatingHeader(header, sourceHeaders);
targetHeaders.Add(messageHeader);
}
}
}
// To and Action (already specified) are 'special' and may be set even with AddressingVersion.None
targetHeaders.To = to;
if (targetHeaders.MessageVersion.Addressing != AddressingVersion.None)
{
//These are used as correlation IDs. Copy these regardless of manual addressing.
targetHeaders.MessageId = sourceHeaders.MessageId;
targetHeaders.RelatesTo = sourceHeaders.RelatesTo;
if (this.manualAddressing)
{
//These are addresses, only copy when ManualAddressing is enabled
targetHeaders.FaultTo = sourceHeaders.FaultTo;
targetHeaders.ReplyTo = sourceHeaders.ReplyTo;
targetHeaders.From = sourceHeaders.From;
}
}
}
public void TestAddMethod()
{
MessageHeaders messageHeaders = new MessageHeaders(null);
messageHeaders.Add("foo", "bar");
}
internal static void AddHeader(MessageHeaders headers, MessageHeader hContext)
{
headers.Add(hContext);
}
void ReadHeaders ()
{
if (headers != null)
throw new InvalidOperationException ("XmlReader at headers is already consumed.");
string envNS = Version.Envelope.Namespace;
headers = new MessageHeaders (version, max_headers);
if (reader.LocalName != "Header" || reader.NamespaceURI != envNS)
return;
bool isEmptyHeader = reader.IsEmptyElement;
reader.ReadStartElement ("Header", envNS);
reader.MoveToContent ();
if (isEmptyHeader)
return;
while (!reader.EOF && reader.NodeType != XmlNodeType.EndElement) {
if (reader.NodeType == XmlNodeType.Element)
headers.Add (new MessageHeader.RawMessageHeader (reader, envNS));
else
reader.Skip ();
// FIXME: handle UnderstoodHeaders as well.
reader.MoveToContent ();
}
reader.ReadEndElement ();
reader.MoveToContent ();
}