internal void GetHeaderAttributes(MessageHeaderDescription headerDescription, out bool mustUnderstand, out bool relay, out string actor) { MessageHeader <object> header = null; if (headerDescription.Multiple) { MessageHeader <object>[] headerArray = (MessageHeader <object>[]) this.attributes[headerDescription.Index]; for (int i = 0; i < headerArray.Length; i++) { if (headerArray[i] != null) { header = headerArray[i]; headerArray[i] = null; break; } } } else { header = (MessageHeader <object>) this.attributes[headerDescription.Index]; } mustUnderstand = header.MustUnderstand; relay = header.Relay; actor = header.Actor; }
internal object GetContentAndSaveHeaderAttributes(object parameterValue, MessageHeaderDescription headerDescription) { if (parameterValue == null) { return(null); } bool mustUnderstand; bool relay; string actor; if (headerDescription.Multiple) { object[] messageHeaderOfTArray = (object[])parameterValue; MessageHeader <object>[] messageHeaderOfTAttributes = new MessageHeader <object> [messageHeaderOfTArray.Length]; Array tArray = Array.CreateInstance(headerDescription.Type, messageHeaderOfTArray.Length); for (int i = 0; i < tArray.Length; i++) { tArray.SetValue(GetContentOfMessageHeaderOfT(headerDescription, messageHeaderOfTArray[i], out mustUnderstand, out relay, out actor), i); messageHeaderOfTAttributes[i] = new MessageHeader <object>(null, mustUnderstand, actor, relay); } _attributes[headerDescription.Index] = messageHeaderOfTAttributes; return(tArray); } else { object content = GetContentOfMessageHeaderOfT(headerDescription, parameterValue, out mustUnderstand, out relay, out actor); _attributes[headerDescription.Index] = new MessageHeader <object>(null, mustUnderstand, actor, relay); return(content); } }
internal void GetHeaderAttributes(MessageHeaderDescription headerDescription, out bool mustUnderstand, out bool relay, out string actor) { MessageHeader <object> matchingMessageHeaderOfTAttribute = null; if (headerDescription.Multiple) { MessageHeader <object>[] messageHeaderOfTAttributes = (MessageHeader <object>[])_attributes[headerDescription.Index]; for (int i = 0; i < messageHeaderOfTAttributes.Length; i++) { if (messageHeaderOfTAttributes[i] != null) { matchingMessageHeaderOfTAttribute = messageHeaderOfTAttributes[i]; messageHeaderOfTAttributes[i] = null; break; } } //assert(matchingMessageHeaderOfTAttribute != null); } else { matchingMessageHeaderOfTAttribute = (MessageHeader <object>)_attributes[headerDescription.Index]; } mustUnderstand = matchingMessageHeaderOfTAttribute.MustUnderstand; relay = matchingMessageHeaderOfTAttribute.Relay; actor = matchingMessageHeaderOfTAttribute.Actor; }
protected override void AddHeadersToMessage(Message message, MessageDescription messageDescription, object[] parameters, bool isRequest) { MessageInfo info = isRequest ? this.requestMessageInfo : this.replyMessageInfo; PartInfo[] headerParts = info.HeaderParts; if ((headerParts != null) && (headerParts.Length != 0)) { MessageHeaders headers = message.Headers; for (int i = 0; i < headerParts.Length; i++) { PartInfo headerPart = headerParts[i]; MessageHeaderDescription description = (MessageHeaderDescription)headerPart.Description; object parameterValue = parameters[description.Index]; if (description.Multiple) { if (parameterValue != null) { bool isXmlElement = description.Type == typeof(XmlElement); foreach (object obj3 in (IEnumerable)parameterValue) { this.AddMessageHeaderForParameter(headers, headerPart, message.Version, obj3, isXmlElement); } } } else { this.AddMessageHeaderForParameter(headers, headerPart, message.Version, parameterValue, false); } } } }
protected override void AddHeadersToMessage(Message message, MessageDescription messageDescription, object[] parameters, bool isRequest) { MessageInfo messageInfo = isRequest ? requestMessageInfo : replyMessageInfo; PartInfo[] headerParts = messageInfo.HeaderParts; if (headerParts == null || headerParts.Length == 0) { return; } MessageHeaders headers = message.Headers; for (int i = 0; i < headerParts.Length; i++) { PartInfo headerPart = headerParts[i]; MessageHeaderDescription headerDescription = (MessageHeaderDescription)headerPart.Description; object headerValue = parameters[headerDescription.Index]; if (headerDescription.Multiple) { if (headerValue != null) { bool isXmlElement = headerDescription.Type == typeof(XmlElement); foreach (object headerItemValue in (IEnumerable)headerValue) { AddMessageHeaderForParameter(headers, headerPart, message.Version, headerItemValue, isXmlElement); } } } else { AddMessageHeaderForParameter(headers, headerPart, message.Version, headerValue, false /*isXmlElement*/); } } }
internal object GetContentAndSaveHeaderAttributes(object parameterValue, MessageHeaderDescription headerDescription) { bool flag; bool flag2; string str; if (parameterValue == null) { return(null); } if (headerDescription.Multiple) { object[] objArray = (object[])parameterValue; MessageHeader <object>[] headerArray = new MessageHeader <object> [objArray.Length]; Array array = Array.CreateInstance(headerDescription.Type, objArray.Length); for (int i = 0; i < array.Length; i++) { array.SetValue(OperationFormatter.GetContentOfMessageHeaderOfT(headerDescription, objArray[i], out flag, out flag2, out str), i); headerArray[i] = new MessageHeader <object>(null, flag, str, flag2); } this.attributes[headerDescription.Index] = headerArray; return(array); } object obj2 = OperationFormatter.GetContentOfMessageHeaderOfT(headerDescription, parameterValue, out flag, out flag2, out str); this.attributes[headerDescription.Index] = new MessageHeader <object>(null, flag, str, flag2); return(obj2); }
// Methods internal MessageHeaderDescription(MessageHeaderDescription other) : base(other) { this.MustUnderstand = other.MustUnderstand; this.Relay = other.Relay; this.Actor = other.Actor; this.TypedHeader = other.TypedHeader; this.IsUnknownHeaderCollection = other.IsUnknownHeaderCollection; }
internal static object GetContentOfMessageHeaderOfT(MessageHeaderDescription headerDescription, object parameterValue, out bool mustUnderstand, out bool relay, out string actor) { actor = headerDescription.Actor; mustUnderstand = headerDescription.MustUnderstand; relay = headerDescription.Relay; if (headerDescription.TypedHeader && (parameterValue != null)) { parameterValue = TypedHeaderManager.GetContent(headerDescription.Type, parameterValue, out mustUnderstand, out relay, out actor); } return(parameterValue); }
private static void AddHeaderProtectionRequirements(MessageHeaderDescription header, MessagePartSpecification signedParts, MessagePartSpecification encryptedParts, ProtectionLevel defaultProtectionLevel) { ProtectionLevel level = header.HasProtectionLevel ? header.ProtectionLevel : defaultProtectionLevel; if (level != ProtectionLevel.None) { XmlQualifiedName item = new XmlQualifiedName(header.Name, header.Namespace); signedParts.HeaderTypes.Add(item); if (level == ProtectionLevel.EncryptAndSign) { encryptedParts.HeaderTypes.Add(item); } } }
private static void AddUnknownHeader(MessageHeaderDescription unknownHeaderDescription, ArrayList unknownHeaders, XmlDocument xmlDoc, XmlDictionaryWriter bufferWriter, MessageHeaderInfo header, XmlDictionaryReader headerReader) { object content = xmlDoc.ReadNode(headerReader); if (bufferWriter != null) { ((XmlElement)content).WriteTo(bufferWriter); } if ((content != null) && unknownHeaderDescription.TypedHeader) { content = TypedHeaderManager.Create(unknownHeaderDescription.Type, content, header.MustUnderstand, header.Relay, header.Actor); } unknownHeaders.Add(content); }
private MessageInfo CreateMessageInfo(DataContractFormatAttribute dataContractFormatAttribute, MessageDescription messageDescription, DataContractSerializerOperationBehavior serializerFactory) { if (messageDescription.IsUntypedMessage) { return(null); } MessageInfo messageInfo = new MessageInfo(); MessageBodyDescription body = messageDescription.Body; if (body.WrapperName != null) { messageInfo.WrapperName = AddToDictionary(body.WrapperName); messageInfo.WrapperNamespace = AddToDictionary(body.WrapperNamespace); } MessagePartDescriptionCollection parts = body.Parts; messageInfo.BodyParts = new PartInfo[parts.Count]; for (int i = 0; i < parts.Count; i++) { messageInfo.BodyParts[i] = CreatePartInfo(parts[i], dataContractFormatAttribute.Style, serializerFactory); } if (IsValidReturnValue(messageDescription.Body.ReturnValue)) { messageInfo.ReturnPart = CreatePartInfo(messageDescription.Body.ReturnValue, dataContractFormatAttribute.Style, serializerFactory); } messageInfo.HeaderDescriptionTable = new MessageHeaderDescriptionTable(); messageInfo.HeaderParts = new PartInfo[messageDescription.Headers.Count]; for (int i = 0; i < messageDescription.Headers.Count; i++) { MessageHeaderDescription headerDescription = messageDescription.Headers[i]; if (headerDescription.IsUnknownHeaderCollection) { messageInfo.UnknownHeaderDescription = headerDescription; } else { ValidateDataContractType(headerDescription.Type); messageInfo.HeaderDescriptionTable.Add(headerDescription.Name, headerDescription.Namespace, headerDescription); } messageInfo.HeaderParts[i] = CreatePartInfo(headerDescription, OperationFormatStyle.Document, serializerFactory); } messageInfo.AnyHeaders = messageInfo.UnknownHeaderDescription != null || messageInfo.HeaderDescriptionTable.Count > 0; return(messageInfo); }
internal void SetHeaderAttributes(MessageHeaderDescription headerDescription, bool mustUnderstand, bool relay, string actor) { if (headerDescription.Multiple) { if (this.attributes[headerDescription.Index] == null) { this.attributes[headerDescription.Index] = new List <MessageHeader <object> >(); } ((List <MessageHeader <object> >) this.attributes[headerDescription.Index]).Add(new MessageHeader <object>(null, mustUnderstand, actor, relay)); } else { this.attributes[headerDescription.Index] = new MessageHeader <object>(null, mustUnderstand, actor, relay); } }
void IOperationContractGenerationExtension.GenerateOperation(OperationContractGenerationContext context) { foreach (KeyValuePair <MessageHeaderDescription, SoapHeaderDirection> pair in headers) { MessageHeaderDescription header = pair.Key; string headerTypeName = (string)ReflectionUtils.GetValue(header, "BaseType"); CodeAttributeArgument arg1 = new CodeAttributeArgument(new CodePrimitiveExpression(header.Name)); CodeAttributeArgument arg2 = new CodeAttributeArgument(new CodeTypeOfExpression(headerTypeName)); CodeAttributeArgument arg3 = new CodeAttributeArgument("Direction", new CodeFieldReferenceExpression( new CodeTypeReferenceExpression(typeof(SoapHeaderDirection)), pair.Value.ToString())); CodeAttributeDeclaration attrib = new CodeAttributeDeclaration(new CodeTypeReference(typeof(SoapHeaderAttribute)), arg1, arg2, arg3); context.SyncMethod.CustomAttributes.Add(attrib); } }
void IWsdlExportExtension.ExportContract(WsdlExporter exporter, WsdlContractConversionContext context) { // Build the custom header description var headerDescription = new MessageHeaderDescription(CustomHeader.Name, CustomHeader.Namespace); headerDescription.Type = typeof(CustomHeader); // Loop through all the operations defined for the contract and add custom SOAP header to the WSDL foreach (OperationDescription op in context.Contract.Operations) { foreach (MessageDescription messageDescription in op.Messages) { messageDescription.Headers.Add(headerDescription); } } }
static void AddHeaderProtectionRequirements(MessageHeaderDescription header, MessagePartSpecification signedParts, MessagePartSpecification encryptedParts, ProtectionLevel defaultProtectionLevel) { var p = defaultProtectionLevel; //header.HasProtectionLevel currently is always false; //ProtectionLevel p = header.HasProtectionLevel ? header.ProtectionLevel : defaultProtectionLevel; if (p != ProtectionLevel.None) { var headerName = new XmlQualifiedName(header.Name, header.Namespace); signedParts.HeaderTypes.Add(headerName); if (p == ProtectionLevel.EncryptAndSign) { encryptedParts.HeaderTypes.Add(headerName); } } }
internal static void AddSoapHeader(OperationDescription op, SoapHeaderAttribute soapHeader) { string headerNamespace = SoapHeaderHelper.GetNamespace(soapHeader.Type); MessageHeaderDescription header = new MessageHeaderDescription(soapHeader.Name, headerNamespace); header.Type = soapHeader.Type; bool input = ((soapHeader.Direction & SoapHeaderDirection.In) == SoapHeaderDirection.In); bool output = ((soapHeader.Direction & SoapHeaderDirection.Out) == SoapHeaderDirection.Out); foreach (MessageDescription msgDescription in op.Messages) { if ((msgDescription.Direction == MessageDirection.Input && input) || (msgDescription.Direction == MessageDirection.Output && output)) { msgDescription.Headers.Add(header); } } }
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)); }
internal object CreateMessageHeader(MessageHeaderDescription headerDescription, object headerValue) { if (headerDescription.Multiple) { IList <MessageHeader <object> > list = (IList <MessageHeader <object> >) this.attributes[headerDescription.Index]; object[] objArray = (object[])Array.CreateInstance(TypedHeaderManager.GetMessageHeaderType(headerDescription.Type), list.Count); Array array = (Array)headerValue; for (int i = 0; i < objArray.Length; i++) { MessageHeader <object> header = list[i]; objArray[i] = TypedHeaderManager.Create(headerDescription.Type, array.GetValue(i), header.MustUnderstand, header.Relay, header.Actor); } return(objArray); } MessageHeader <object> header2 = (MessageHeader <object>) this.attributes[headerDescription.Index]; return(TypedHeaderManager.Create(headerDescription.Type, headerValue, header2.MustUnderstand, header2.Relay, header2.Actor)); }
private MessageInfo CreateMessageInfo(DataContractFormatAttribute dataContractFormatAttribute, MessageDescription messageDescription, DataContractSerializerOperationBehavior serializerFactory) { if (messageDescription.IsUntypedMessage) { return(null); } MessageInfo info = new MessageInfo(); MessageBodyDescription body = messageDescription.Body; if (body.WrapperName != null) { info.WrapperName = base.AddToDictionary(body.WrapperName); info.WrapperNamespace = base.AddToDictionary(body.WrapperNamespace); } MessagePartDescriptionCollection parts = body.Parts; info.BodyParts = new PartInfo[parts.Count]; for (int i = 0; i < parts.Count; i++) { info.BodyParts[i] = this.CreatePartInfo(parts[i], dataContractFormatAttribute.Style, serializerFactory); } if (OperationFormatter.IsValidReturnValue(messageDescription.Body.ReturnValue)) { info.ReturnPart = this.CreatePartInfo(messageDescription.Body.ReturnValue, dataContractFormatAttribute.Style, serializerFactory); } info.HeaderDescriptionTable = new OperationFormatter.MessageHeaderDescriptionTable(); info.HeaderParts = new PartInfo[messageDescription.Headers.Count]; for (int j = 0; j < messageDescription.Headers.Count; j++) { MessageHeaderDescription message = messageDescription.Headers[j]; if (message.IsUnknownHeaderCollection) { info.UnknownHeaderDescription = message; } else { this.ValidateDataContractType(message.Type); info.HeaderDescriptionTable.Add(message.Name, message.Namespace, message); } info.HeaderParts[j] = this.CreatePartInfo(message, OperationFormatStyle.Document, serializerFactory); } info.AnyHeaders = (info.UnknownHeaderDescription != null) || (info.HeaderDescriptionTable.Count > 0); return(info); }
protected void AddMessageHeader(MessageDescription message, string headerNamespace, string headerName, Type headerType) { if (message != null) { MessageBodyDescription messageBody = message.Body; if (messageBody != null) { if (headerNamespace.IsEmpty()) { if (!messageBody.WrapperNamespace.IsEmpty()) { headerNamespace = messageBody.WrapperNamespace; if (!messageBody.WrapperName.IsEmpty()) { headerNamespace += "." + messageBody.Parts[1].Name; } } else if (messageBody.Parts != null && messageBody.Parts.Count > 0) { headerNamespace = messageBody.Parts[0].Namespace; } } if (!headerNamespace.IsEmpty()) { MessageHeaderDescription header = (from h in message.Headers.OfType <MessageHeaderDescription>() where h.Name.IgnoreCaseCompare(headerName) && h.Namespace.IgnoreCaseCompare(headerNamespace) select h).FirstOrDefault(); if (header == null) { header = new MessageHeaderDescription(headerName, headerNamespace); header.MustUnderstand = true; header.MemberInfo = headerType; header.Type = headerType; header.TypedHeader = true; message.Headers.Add(header); } } } } }
public void ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context) { // Build the custom header description var headerDescription = new MessageHeaderDescription(CustomHeader.Name, CustomHeader.Namespace); headerDescription.Type = typeof(CustomHeader); var headers = context.ContractConversionContext.Contract.Operations; // Loop through all the operations defined for the contract and add custom SOAP header to the WSDL //foreach (OperationDescription op in context.ContractConversionContext.Contract.Operations) //{ // foreach (MessageDescription messageDescription in op.Messages) // { // var exist = messageDescription.Headers.Any(x => x.Equals(headerDescription)); // if(!exist) // messageDescription.Headers.Add(headerDescription); // } //} }
static void AddPartProtectionRequirements(List <XmlQualifiedName> enc, List <XmlQualifiedName> sig, MessageHeaderDescription pd, ChannelProtectionRequirements cp) { if (!pd.HasProtectionLevel) { return; // no specific part indication } switch (pd.ProtectionLevel) { case ProtectionLevel.EncryptAndSign: enc.Add(new XmlQualifiedName(pd.Name, pd.Namespace)); goto case ProtectionLevel.Sign; case ProtectionLevel.Sign: sig.Add(new XmlQualifiedName(pd.Name, pd.Namespace)); break; } }
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)); } }
internal object CreateMessageHeader(MessageHeaderDescription headerDescription, object headerValue) { if (headerDescription.Multiple) { IList <MessageHeader <object> > messageHeaderOfTAttributes = (IList <MessageHeader <object> >)_attributes[headerDescription.Index]; object[] messageHeaderOfTArray = (object[])Array.CreateInstance(TypedHeaderManager.GetMessageHeaderType(headerDescription.Type), messageHeaderOfTAttributes.Count); Array headerValues = (Array)headerValue; for (int i = 0; i < messageHeaderOfTArray.Length; i++) { MessageHeader <object> messageHeaderOfTAttribute = messageHeaderOfTAttributes[i]; messageHeaderOfTArray[i] = TypedHeaderManager.Create(headerDescription.Type, headerValues.GetValue(i), messageHeaderOfTAttribute.MustUnderstand, messageHeaderOfTAttribute.Relay, messageHeaderOfTAttribute.Actor); } return(messageHeaderOfTArray); } else { MessageHeader <object> messageHeaderOfTAttribute = (MessageHeader <object>)_attributes[headerDescription.Index]; return(TypedHeaderManager.Create(headerDescription.Type, headerValue, messageHeaderOfTAttribute.MustUnderstand, messageHeaderOfTAttribute.Relay, messageHeaderOfTAttribute.Actor)); } }
protected override void GetHeadersFromMessage(Message message, MessageDescription messageDescription, object[] parameters, bool isRequest) { try { XmlSerializer headerSerializer; OperationFormatter.MessageHeaderDescriptionTable headerDescriptionTable; MessageHeaderDescription unknownHeaderDescription; if (isRequest) { headerSerializer = this.requestMessageInfo.HeaderSerializer; headerDescriptionTable = this.requestMessageInfo.HeaderDescriptionTable; unknownHeaderDescription = this.requestMessageInfo.UnknownHeaderDescription; } else { headerSerializer = this.replyMessageInfo.HeaderSerializer; headerDescriptionTable = this.replyMessageInfo.HeaderDescriptionTable; unknownHeaderDescription = this.replyMessageInfo.UnknownHeaderDescription; } MessageHeaders headers = message.Headers; ArrayList unknownHeaders = null; XmlDocument xmlDoc = null; if (unknownHeaderDescription != null) { unknownHeaders = new ArrayList(); xmlDoc = new XmlDocument(); } if (headerSerializer == null) { if (unknownHeaderDescription != null) { for (int i = 0; i < headers.Count; i++) { AddUnknownHeader(unknownHeaderDescription, unknownHeaders, xmlDoc, null, headers[i], headers.GetReaderAtHeader(i)); } parameters[unknownHeaderDescription.Index] = unknownHeaders.ToArray(unknownHeaderDescription.TypedHeader ? typeof(MessageHeader <XmlElement>) : typeof(XmlElement)); } } else { MemoryStream stream = new MemoryStream(); XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(stream); message.WriteStartEnvelope(writer); message.WriteStartHeaders(writer); MessageHeaderOfTHelper helper = null; for (int j = 0; j < headers.Count; j++) { MessageHeaderInfo headerInfo = headers[j]; XmlDictionaryReader readerAtHeader = headers.GetReaderAtHeader(j); MessageHeaderDescription headerDescription = headerDescriptionTable.Get(headerInfo.Name, headerInfo.Namespace); if (headerDescription != null) { if (headerInfo.MustUnderstand) { headers.UnderstoodHeaders.Add(headerInfo); } if (headerDescription.TypedHeader) { if (helper == null) { helper = new MessageHeaderOfTHelper(parameters.Length); } helper.SetHeaderAttributes(headerDescription, headerInfo.MustUnderstand, headerInfo.Relay, headerInfo.Actor); } } if ((headerDescription == null) && (unknownHeaderDescription != null)) { AddUnknownHeader(unknownHeaderDescription, unknownHeaders, xmlDoc, writer, headerInfo, readerAtHeader); } else { writer.WriteNode(readerAtHeader, false); } readerAtHeader.Close(); } writer.WriteEndElement(); writer.WriteEndElement(); writer.Flush(); stream.Position = 0L; XmlDictionaryReader xmlReader = XmlDictionaryReader.CreateTextReader(stream.GetBuffer(), 0, (int)stream.Length, XmlDictionaryReaderQuotas.Max); xmlReader.ReadStartElement(); xmlReader.MoveToContent(); if (!xmlReader.IsEmptyElement) { xmlReader.ReadStartElement(); object[] objArray = (object[])headerSerializer.Deserialize(xmlReader, this.isEncoded ? GetEncoding(message.Version.Envelope) : null); int num3 = 0; foreach (MessageHeaderDescription description3 in messageDescription.Headers) { if (!description3.IsUnknownHeaderCollection) { object headerValue = objArray[num3++]; if (description3.TypedHeader && (headerValue != null)) { headerValue = helper.CreateMessageHeader(description3, headerValue); } parameters[description3.Index] = headerValue; } } xmlReader.Close(); } if (unknownHeaderDescription != null) { parameters[unknownHeaderDescription.Index] = unknownHeaders.ToArray(unknownHeaderDescription.TypedHeader ? typeof(MessageHeader <XmlElement>) : typeof(XmlElement)); } } } catch (InvalidOperationException exception) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(System.ServiceModel.SR.GetString("SFxErrorDeserializingHeader", new object[] { messageDescription.MessageName }), exception)); } }
protected override void AddHeadersToMessage(Message message, MessageDescription messageDescription, object[] parameters, bool isRequest) { XmlSerializer serializer; MessageHeaderDescriptionTable headerDescriptionTable; MessageHeaderDescription unknownHeaderDescription; bool mustUnderstand; bool relay; string actor; try { if (isRequest) { serializer = _requestMessageInfo.HeaderSerializer; headerDescriptionTable = _requestMessageInfo.HeaderDescriptionTable; unknownHeaderDescription = _requestMessageInfo.UnknownHeaderDescription; } else { serializer = _replyMessageInfo.HeaderSerializer; headerDescriptionTable = _replyMessageInfo.HeaderDescriptionTable; unknownHeaderDescription = _replyMessageInfo.UnknownHeaderDescription; } if (serializer != null) { object[] headerValues = new object[headerDescriptionTable.Count]; MessageHeaderOfTHelper messageHeaderOfTHelper = null; int headerIndex = 0; foreach (MessageHeaderDescription headerDescription in messageDescription.Headers) { object parameterValue = parameters[headerDescription.Index]; if (!headerDescription.IsUnknownHeaderCollection) { if (headerDescription.TypedHeader) { if (messageHeaderOfTHelper == null) { messageHeaderOfTHelper = new MessageHeaderOfTHelper(parameters.Length); } headerValues[headerIndex++] = messageHeaderOfTHelper.GetContentAndSaveHeaderAttributes(parameters[headerDescription.Index], headerDescription); } else { headerValues[headerIndex++] = parameterValue; } } } MemoryStream memoryStream = new MemoryStream(); XmlDictionaryWriter bufferWriter = XmlDictionaryWriter.CreateTextWriter(memoryStream); bufferWriter.WriteStartElement("root"); serializer.Serialize(bufferWriter, headerValues, null, _isEncoded ? GetEncoding(message.Version.Envelope) : null); bufferWriter.WriteEndElement(); bufferWriter.Flush(); XmlDocument doc = new XmlDocument(); memoryStream.Position = 0; doc.Load(memoryStream); foreach (XmlElement element in doc.DocumentElement.ChildNodes) { MessageHeaderDescription matchingHeaderDescription = headerDescriptionTable.Get(element.LocalName, element.NamespaceURI); if (matchingHeaderDescription == null) { message.Headers.Add(new XmlElementMessageHeader(this, message.Version, element.LocalName, element.NamespaceURI, false /*mustUnderstand*/, null /*actor*/, false /*relay*/, element)); } else { if (matchingHeaderDescription.TypedHeader) { messageHeaderOfTHelper.GetHeaderAttributes(matchingHeaderDescription, out mustUnderstand, out relay, out actor); } else { mustUnderstand = matchingHeaderDescription.MustUnderstand; relay = matchingHeaderDescription.Relay; actor = matchingHeaderDescription.Actor; } message.Headers.Add(new XmlElementMessageHeader(this, message.Version, element.LocalName, element.NamespaceURI, mustUnderstand, actor, relay, element)); } } } if (unknownHeaderDescription != null && parameters[unknownHeaderDescription.Index] != null) { foreach (object unknownHeader in (IEnumerable)parameters[unknownHeaderDescription.Index]) { XmlElement element = (XmlElement)GetContentOfMessageHeaderOfT(unknownHeaderDescription, unknownHeader, out mustUnderstand, out relay, out actor); if (element != null) { message.Headers.Add(new XmlElementMessageHeader(this, message.Version, element.LocalName, element.NamespaceURI, mustUnderstand, actor, relay, element)); } } } } catch (InvalidOperationException e) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException( SR.Format(SR.SFxErrorSerializingHeader, messageDescription.MessageName, e.Message), e)); } }
MessageHeader CreateHeader(MessageHeaderDescription mh, object value) { return(MessageHeader.CreateHeader(mh.Name, mh.Namespace, value, mh.MustUnderstand, mh.Actor, mh.Relay)); }
public static string GetHeaderType(this MessageHeaderDescription header) { return((string)ReflectionUtils.GetValue(header, "BaseType")); }
protected override void GetHeadersFromMessage(Message message, MessageDescription messageDescription, object[] parameters, bool isRequest) { MessageInfo messageInfo = isRequest ? requestMessageInfo : replyMessageInfo; if (!messageInfo.AnyHeaders) { return; } MessageHeaders headers = message.Headers; KeyValuePair <Type, ArrayList>[] multipleHeaderValues = null; ArrayList elementList = null; if (messageInfo.UnknownHeaderDescription != null) { elementList = new ArrayList(); } for (int i = 0; i < headers.Count; i++) { MessageHeaderInfo header = headers[i]; MessageHeaderDescription headerDescription = messageInfo.HeaderDescriptionTable.Get(header.Name, header.Namespace); if (headerDescription != null) { if (header.MustUnderstand) { headers.UnderstoodHeaders.Add(header); } object item = null; XmlDictionaryReader headerReader = headers.GetReaderAtHeader(i); try { object dataValue = DeserializeHeaderContents(headerReader, messageDescription, headerDescription); if (headerDescription.TypedHeader) { item = TypedHeaderManager.Create(headerDescription.Type, dataValue, headers[i].MustUnderstand, headers[i].Relay, headers[i].Actor); } else { item = dataValue; } } finally { headerReader.Dispose(); } if (headerDescription.Multiple) { if (multipleHeaderValues == null) { multipleHeaderValues = new KeyValuePair <Type, ArrayList> [parameters.Length]; } if (multipleHeaderValues[headerDescription.Index].Key == null) { multipleHeaderValues[headerDescription.Index] = new KeyValuePair <System.Type, System.Collections.ArrayList>(headerDescription.TypedHeader ? TypedHeaderManager.GetMessageHeaderType(headerDescription.Type) : headerDescription.Type, new ArrayList()); } multipleHeaderValues[headerDescription.Index].Value.Add(item); } else { parameters[headerDescription.Index] = item; } } else if (messageInfo.UnknownHeaderDescription != null) { MessageHeaderDescription unknownHeaderDescription = messageInfo.UnknownHeaderDescription; XmlDictionaryReader headerReader = headers.GetReaderAtHeader(i); try { XmlDocument doc = new XmlDocument(); object dataValue = doc.ReadNode(headerReader); if (dataValue != null && unknownHeaderDescription.TypedHeader) { dataValue = TypedHeaderManager.Create(unknownHeaderDescription.Type, dataValue, headers[i].MustUnderstand, headers[i].Relay, headers[i].Actor); } elementList.Add(dataValue); } finally { headerReader.Dispose(); } } } if (multipleHeaderValues != null) { for (int i = 0; i < parameters.Length; i++) { if (multipleHeaderValues[i].Key != null) { parameters[i] = multipleHeaderValues[i].Value.ToArray(multipleHeaderValues[i].Key); } } } if (messageInfo.UnknownHeaderDescription != null) { parameters[messageInfo.UnknownHeaderDescription.Index] = elementList.ToArray(messageInfo.UnknownHeaderDescription.TypedHeader ? typeof(MessageHeader <XmlElement>) : typeof(XmlElement)); } }
protected override void AddHeadersToMessage(Message message, MessageDescription messageDescription, object[] parameters, bool isRequest) { try { XmlSerializer headerSerializer; OperationFormatter.MessageHeaderDescriptionTable headerDescriptionTable; MessageHeaderDescription unknownHeaderDescription; bool mustUnderstand; bool relay; string actor; if (isRequest) { headerSerializer = this.requestMessageInfo.HeaderSerializer; headerDescriptionTable = this.requestMessageInfo.HeaderDescriptionTable; unknownHeaderDescription = this.requestMessageInfo.UnknownHeaderDescription; } else { headerSerializer = this.replyMessageInfo.HeaderSerializer; headerDescriptionTable = this.replyMessageInfo.HeaderDescriptionTable; unknownHeaderDescription = this.replyMessageInfo.UnknownHeaderDescription; } if (headerSerializer != null) { object[] o = new object[headerDescriptionTable.Count]; MessageHeaderOfTHelper helper = null; int num = 0; foreach (MessageHeaderDescription description2 in messageDescription.Headers) { object obj2 = parameters[description2.Index]; if (!description2.IsUnknownHeaderCollection) { if (description2.TypedHeader) { if (helper == null) { helper = new MessageHeaderOfTHelper(parameters.Length); } o[num++] = helper.GetContentAndSaveHeaderAttributes(parameters[description2.Index], description2); } else { o[num++] = obj2; } } } MemoryStream stream = new MemoryStream(); XmlDictionaryWriter xmlWriter = XmlDictionaryWriter.CreateTextWriter(stream); xmlWriter.WriteStartElement("root"); headerSerializer.Serialize(xmlWriter, o, null, this.isEncoded ? GetEncoding(message.Version.Envelope) : null); xmlWriter.WriteEndElement(); xmlWriter.Flush(); XmlDocument document = new XmlDocument(); stream.Position = 0L; document.Load(stream); foreach (XmlElement element in document.DocumentElement.ChildNodes) { MessageHeaderDescription headerDescription = headerDescriptionTable.Get(element.LocalName, element.NamespaceURI); if (headerDescription == null) { message.Headers.Add(new OperationFormatter.XmlElementMessageHeader(this, message.Version, element.LocalName, element.NamespaceURI, false, null, false, element)); } else { if (headerDescription.TypedHeader) { helper.GetHeaderAttributes(headerDescription, out mustUnderstand, out relay, out actor); } else { mustUnderstand = headerDescription.MustUnderstand; relay = headerDescription.Relay; actor = headerDescription.Actor; } message.Headers.Add(new OperationFormatter.XmlElementMessageHeader(this, message.Version, element.LocalName, element.NamespaceURI, mustUnderstand, actor, relay, element)); } } } if ((unknownHeaderDescription != null) && (parameters[unknownHeaderDescription.Index] != null)) { foreach (object obj3 in (IEnumerable)parameters[unknownHeaderDescription.Index]) { XmlElement headerValue = (XmlElement)OperationFormatter.GetContentOfMessageHeaderOfT(unknownHeaderDescription, obj3, out mustUnderstand, out relay, out actor); if (headerValue != null) { message.Headers.Add(new OperationFormatter.XmlElementMessageHeader(this, message.Version, headerValue.LocalName, headerValue.NamespaceURI, mustUnderstand, actor, relay, headerValue)); } } } } catch (InvalidOperationException exception) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(System.ServiceModel.SR.GetString("SFxErrorSerializingHeader", new object[] { messageDescription.MessageName, exception.Message }), exception)); } }
private object DeserializeHeaderContents(XmlDictionaryReader reader, MessageDescription messageDescription, MessageHeaderDescription headerDescription) { Type dataContractType = GetSubstituteDataContractType(headerDescription.Type, out bool isQueryable); XmlObjectSerializer serializerLocal = _serializerFactory.CreateSerializer(dataContractType, headerDescription.Name, headerDescription.Namespace, _knownTypes); object val = serializerLocal.ReadObject(reader); if (isQueryable && val != null) { return(Queryable.AsQueryable((IEnumerable)val)); } return(val); }
bool IEqualityComparerMessageDescription.Equals(MessageDescription x, MessageDescription y) { if (x.XsdTypeName != y.XsdTypeName) { return false; } if (x.Headers.Count != y.Headers.Count) { return false; } MessageHeaderDescription[] array = new MessageHeaderDescription[x.Headers.Count]; x.Headers.CopyTo(array, 0); MessageHeaderDescription[] descriptionArray2 = new MessageHeaderDescription[y.Headers.Count]; y.Headers.CopyTo(descriptionArray2, 0); if (x.Headers.Count 1) { Array.SortMessagePartDescription((MessagePartDescription[]) array, MessagePartDescriptionComparer.Singleton); Array.SortMessagePartDescription((MessagePartDescription[]) descriptionArray2, MessagePartDescriptionComparer.Singleton); } for (int i = 0; i array.Length; i++) { if (MessagePartDescriptionComparer.Singleton.Compare(array[i], descriptionArray2[i]) != 0) { return false; } } return true; }