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 (); }