/// <summary>
/// Add the Ping method to the existing contract
/// </summary>
private void AddPingToContractDescription(ContractDescription contractDescription)
{
OperationDescription pingOperationDescription = new OperationDescription(PingOperationName, contractDescription);
MessageDescription inputMessageDescription = new MessageDescription(
GetAction(contractDescription, PingOperationName),
MessageDirection.Input);
MessageDescription outputMessageDescription = new MessageDescription(
GetAction(contractDescription, PingResponse),
MessageDirection.Output);
MessagePartDescription returnValue = new MessagePartDescription("PingResult", contractDescription.Namespace);
returnValue.Type = typeof(DateTime);
outputMessageDescription.Body.ReturnValue = returnValue;
inputMessageDescription.Body.WrapperName = PingOperationName;
inputMessageDescription.Body.WrapperNamespace = contractDescription.Namespace;
outputMessageDescription.Body.WrapperName = PingResponse;
outputMessageDescription.Body.WrapperNamespace = contractDescription.Namespace;
pingOperationDescription.Messages.Add(inputMessageDescription);
pingOperationDescription.Messages.Add(outputMessageDescription);
pingOperationDescription.Behaviors.Add(new DataContractSerializerOperationBehavior(pingOperationDescription));
pingOperationDescription.Behaviors.Add(new PingOperationBehavior());
contractDescription.Operations.Add(pingOperationDescription);
}
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 void AddParameterOrder(MessageDescription message)
{
if (this.operation != null)
{
Operation operation = this.contractContext.GetOperation(this.operation);
if (operation != null)
{
if (operation.ParameterOrder == null)
{
operation.ParameterOrder = new string[this.GetParameterCount()];
}
if (operation.ParameterOrder.Length != 0)
{
foreach (MessagePartDescription description in message.Body.Parts)
{
ParameterInfo additionalAttributesProvider = description.AdditionalAttributesProvider as ParameterInfo;
if ((additionalAttributesProvider != null) && (additionalAttributesProvider.Position >= 0))
{
operation.ParameterOrder[additionalAttributesProvider.Position] = description.Name;
}
}
}
}
}
}
internal static StreamFormatter Create(MessageDescription messageDescription, string operationName, bool isRequest)
{
MessagePartDescription streamPart = ValidateAndGetStreamPart(messageDescription, isRequest, operationName);
if (streamPart == null)
return null;
return new StreamFormatter(messageDescription, streamPart, operationName, isRequest);
}
protected override object [] MessageToParts (MessageDescription md, Message message)
{
if (message.IsEmpty)
return null;
XmlDictionaryReader r = message.GetReaderAtBodyContents ();
return (object []) GetSerializer (md.Body).Deserialize (r);
}
private static KeyValuePair<string, ComplexType> getExistingElement(XmlTypeExtractor schemaImporter, MessageDescription message)
{
Func<KeyValuePair<string, ComplexType>, bool> existingElementPredicate =
_ => _.Key == message.Body.WrapperNamespace && _.Value.Name == message.Body.WrapperName;
if (!schemaImporter.Elements.Any(existingElementPredicate))
{
throw new InvalidOperationException("Couldn't find the element definition");
}
var existingElement = schemaImporter.Elements.Single(existingElementPredicate);
return existingElement;
}
private static bool IsUntypedMessage(MessageDescription message)
{
if (message == null)
{
return false;
}
return ((((message.Body.ReturnValue != null) &&
(message.Body.Parts.Count == 0)) &&
(message.Body.ReturnValue.Type == typeof(Message))) ||
(((message.Body.ReturnValue == null) && (message.Body.Parts.Count == 1)) &&
(message.Body.Parts[0].Type == typeof(Message))));
}
private StreamFormatter(MessageDescription messageDescription, MessagePartDescription streamPart, string operationName, bool isRequest)
{
if ((object)streamPart == (object)messageDescription.Body.ReturnValue)
_streamIndex = returnValueIndex;
else
_streamIndex = streamPart.Index;
_wrapperName = messageDescription.Body.WrapperName;
_wrapperNS = messageDescription.Body.WrapperNamespace;
_partName = streamPart.Name;
_partNS = streamPart.Namespace;
_isRequest = isRequest;
_operationName = operationName;
}
private static MessagePartDescription GetStreamPart(MessageDescription messageDescription)
{
if (OperationFormatter.IsValidReturnValue(messageDescription.Body.ReturnValue))
{
if ((messageDescription.Body.Parts.Count == 0) && (messageDescription.Body.ReturnValue.Type == typeof(Stream)))
{
return messageDescription.Body.ReturnValue;
}
}
else if ((messageDescription.Body.Parts.Count == 1) && (messageDescription.Body.Parts[0].Type == typeof(Stream)))
{
return messageDescription.Body.Parts[0];
}
return null;
}
private static bool HasStream(MessageDescription messageDescription)
{
if ((messageDescription.Body.ReturnValue != null) && (messageDescription.Body.ReturnValue.Type == typeof(Stream)))
{
return true;
}
foreach (MessagePartDescription description in messageDescription.Body.Parts)
{
if (description.Type == typeof(Stream))
{
return true;
}
}
return false;
}
public PrimitiveOperationFormatter(OperationDescription description, bool isRpc)
{
if (description == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("description");
OperationFormatter.Validate(description, isRpc, false/*isEncoded*/);
this.operation = description;
#pragma warning suppress 56506 // Microsoft, OperationDescription.Messages never be null
this.requestMessage = description.Messages[0];
if (description.Messages.Count == 2)
this.responseMessage = description.Messages[1];
int stringCount = 3 + requestMessage.Body.Parts.Count;
if (responseMessage != null)
stringCount += 2 + responseMessage.Body.Parts.Count;
XmlDictionary dictionary = new XmlDictionary(stringCount * 2);
xsiNilLocalName = dictionary.Add("nil");
xsiNilNamespace = dictionary.Add(System.Xml.Schema.XmlSchema.InstanceNamespace);
OperationFormatter.GetActions(description, dictionary, out this.action, out this.replyAction);
if (requestMessage.Body.WrapperName != null)
{
requestWrapperName = AddToDictionary(dictionary, requestMessage.Body.WrapperName);
requestWrapperNamespace = AddToDictionary(dictionary, requestMessage.Body.WrapperNamespace);
}
requestParts = AddToDictionary(dictionary, requestMessage.Body.Parts, isRpc);
if (responseMessage != null)
{
if (responseMessage.Body.WrapperName != null)
{
responseWrapperName = AddToDictionary(dictionary, responseMessage.Body.WrapperName);
responseWrapperNamespace = AddToDictionary(dictionary, responseMessage.Body.WrapperNamespace);
}
responseParts = AddToDictionary(dictionary, responseMessage.Body.Parts, isRpc);
if (responseMessage.Body.ReturnValue != null && responseMessage.Body.ReturnValue.Type != typeof(void))
{
returnPart = AddToDictionary(dictionary, responseMessage.Body.ReturnValue, isRpc);
}
}
}
public static void AssertMessageAndBodyDescription (
string action, MessageDirection dir,
Type messageType, string bodyWrapperName,
string bodyWrapperNS, bool bodyHasReturn,
MessageDescription md, string label)
{
Assert.AreEqual (action, md.Action, label + " Action");
Assert.AreEqual (dir, md.Direction, label + " Direction");
Assert.AreEqual (messageType, md.MessageType, label + " MessageType");
Assert.AreEqual (bodyWrapperName, md.Body.WrapperName,
label + " Body.WrapperName");
Assert.AreEqual (bodyWrapperNS, md.Body.WrapperNamespace,
label + " Body.WrapperNamespace");
Assert.AreEqual (bodyHasReturn, md.Body.ReturnValue != null,
label + "Body hasReturn");
}
static void ShowMessageBody(MessageDescription message)
{
Console.WriteLine(message.Direction == MessageDirection.Input ?"请求消息：" : "回复消息：");
MessageBodyDescription body = message.Body;
Console.WriteLine("<tns:{0} xmlns:tns=\"{1}\">", body.WrapperName,body.WrapperNamespace);
foreach (var part in body.Parts)
{
Console.WriteLine("\t<tns:{0}>...</tns:{0}>", part.Name);
}
if (null != body.ReturnValue)
{
Console.WriteLine("\t<tns:{0}>...</tns:{0}>",
body.ReturnValue.Name);
}
Console.WriteLine("</tns:{0}>", body.WrapperName);
}
public PrimitiveOperationFormatter(OperationDescription description, bool isRpc)
{
if (description == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("description");
OperationFormatter.Validate(description, isRpc, false/*isEncoded*/);
_operation = description;
_requestMessage = description.Messages[0];
if (description.Messages.Count == 2)
_responseMessage = description.Messages[1];
int stringCount = 3 + _requestMessage.Body.Parts.Count;
if (_responseMessage != null)
stringCount += 2 + _responseMessage.Body.Parts.Count;
XmlDictionary dictionary = new XmlDictionary(stringCount * 2);
_xsiNilLocalName = dictionary.Add("nil");
_xsiNilNamespace = dictionary.Add(EndpointAddressProcessor.XsiNs);
OperationFormatter.GetActions(description, dictionary, out _action, out _replyAction);
if (_requestMessage.Body.WrapperName != null)
{
_requestWrapperName = AddToDictionary(dictionary, _requestMessage.Body.WrapperName);
_requestWrapperNamespace = AddToDictionary(dictionary, _requestMessage.Body.WrapperNamespace);
}
_requestParts = AddToDictionary(dictionary, _requestMessage.Body.Parts, isRpc);
if (_responseMessage != null)
{
if (_responseMessage.Body.WrapperName != null)
{
_responseWrapperName = AddToDictionary(dictionary, _responseMessage.Body.WrapperName);
_responseWrapperNamespace = AddToDictionary(dictionary, _responseMessage.Body.WrapperNamespace);
}
_responseParts = AddToDictionary(dictionary, _responseMessage.Body.Parts, isRpc);
if (_responseMessage.Body.ReturnValue != null && _responseMessage.Body.ReturnValue.Type != typeof(void))
{
_returnPart = AddToDictionary(dictionary, _responseMessage.Body.ReturnValue, isRpc);
}
}
}
private static OperationDescription CreatePreflightOperation(OperationDescription operation)
{
ContractDescription contract = operation.DeclaringContract;
var preflightOperation = new OperationDescription(operation.Name + CorsConstants.PreflightSuffix, contract);
var inputMessage = new MessageDescription(
operation.Messages[0].Action + CorsConstants.PreflightSuffix, MessageDirection.Input);
inputMessage.Body.Parts.Add(
new MessagePartDescription("input", contract.Namespace) { Index = 0, Type = typeof(Message) });
preflightOperation.Messages.Add(inputMessage);
var outputMessage = new MessageDescription(
operation.Messages[1].Action + CorsConstants.PreflightSuffix, MessageDirection.Output);
outputMessage.Body.ReturnValue = new MessagePartDescription(
preflightOperation.Name + "Return", contract.Namespace) { Type = typeof(Message) };
preflightOperation.Messages.Add(outputMessage);
return preflightOperation;
}
private StreamFormatter(MessageDescription messageDescription, MessagePartDescription streamPart, string operationName, bool isRequest)
{
if (streamPart == messageDescription.Body.ReturnValue)
{
this.streamIndex = -1;
}
else
{
this.streamIndex = streamPart.Index;
}
this.wrapperName = messageDescription.Body.WrapperName;
this.wrapperNS = messageDescription.Body.WrapperNamespace;
this.partName = streamPart.Name;
this.partNS = streamPart.Namespace;
this.isRequest = isRequest;
this.operationName = operationName;
}
public static void AddMessagePartDescription(OperationDescription operation, bool isResponse, MessageDescription message, string[] argumentNames, Type[] argumentTypes)
{
string ns = operation.DeclaringContract.Namespace;
for (int i = 0; i < argumentNames.Length; i++)
{
string name = argumentNames[i];
MessagePartDescription item = new MessagePartDescription(NamingHelper.XmlName(name), ns) {
Index = i,
Type = argumentTypes[i]
};
message.Body.Parts.Add(item);
}
if (isResponse)
{
SetReturnValue(message, operation);
}
}
internal MessageDescription(MessageDescription other)
{
this.action = other.action;
this.direction = other.direction;
this.Items.Body = other.Items.Body.Clone();
foreach (MessageHeaderDescription description in other.Items.Headers)
{
this.Items.Headers.Add(description.Clone() as MessageHeaderDescription);
}
foreach (MessagePropertyDescription description2 in other.Items.Properties)
{
this.Items.Properties.Add(description2.Clone() as MessagePropertyDescription);
}
this.MessageName = other.MessageName;
this.MessageType = other.MessageType;
this.XsdTypeName = other.XsdTypeName;
this.hasProtectionLevel = other.hasProtectionLevel;
this.ProtectionLevel = other.ProtectionLevel;
}
internal MessageDescription(MessageDescription other)
{
_action = other._action;
_direction = other._direction;
this.Items.Body = other.Items.Body.Clone();
foreach (MessageHeaderDescription mhd in other.Items.Headers)
{
this.Items.Headers.Add(mhd.Clone() as MessageHeaderDescription);
}
foreach (MessagePropertyDescription mpd in other.Items.Properties)
{
this.Items.Properties.Add(mpd.Clone() as MessagePropertyDescription);
}
this.MessageName = other.MessageName;
this.MessageType = other.MessageType;
this.XsdTypeName = other.XsdTypeName;
_hasProtectionLevel = other._hasProtectionLevel;
this.ProtectionLevel = other.ProtectionLevel;
}
public PrimitiveOperationFormatter(OperationDescription description, bool isRpc)
{
if (description == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("description");
}
OperationFormatter.Validate(description, isRpc, false);
this.operation = description;
this.requestMessage = description.Messages[0];
if (description.Messages.Count == 2)
{
this.responseMessage = description.Messages[1];
}
int num = 3 + this.requestMessage.Body.Parts.Count;
if (this.responseMessage != null)
{
num += 2 + this.responseMessage.Body.Parts.Count;
}
XmlDictionary dictionary = new XmlDictionary(num * 2);
this.xsiNilLocalName = dictionary.Add("nil");
this.xsiNilNamespace = dictionary.Add("http://www.w3.org/2001/XMLSchema-instance");
OperationFormatter.GetActions(description, dictionary, out this.action, out this.replyAction);
if (this.requestMessage.Body.WrapperName != null)
{
this.requestWrapperName = AddToDictionary(dictionary, this.requestMessage.Body.WrapperName);
this.requestWrapperNamespace = AddToDictionary(dictionary, this.requestMessage.Body.WrapperNamespace);
}
this.requestParts = AddToDictionary(dictionary, this.requestMessage.Body.Parts, isRpc);
if (this.responseMessage != null)
{
if (this.responseMessage.Body.WrapperName != null)
{
this.responseWrapperName = AddToDictionary(dictionary, this.responseMessage.Body.WrapperName);
this.responseWrapperNamespace = AddToDictionary(dictionary, this.responseMessage.Body.WrapperNamespace);
}
this.responseParts = AddToDictionary(dictionary, this.responseMessage.Body.Parts, isRpc);
if ((this.responseMessage.Body.ReturnValue != null) && (this.responseMessage.Body.ReturnValue.Type != typeof(void)))
{
this.returnPart = AddToDictionary(dictionary, this.responseMessage.Body.ReturnValue, isRpc);
}
}
}
public static void AddMessagePartDescription(OperationDescription operation, bool isResponse, MessageDescription message, Type type, SerializerOption serializerOption)
{
if (type != null)
{
string name;
string str2;
if (serializerOption == SerializerOption.DataContractSerializer)
{
XmlQualifiedName rootElementName = XsdDataContractExporter.GetRootElementName(type);
if (rootElementName == null)
{
rootElementName = XsdDataContractExporter.GetSchemaTypeName(type);
}
if (!rootElementName.IsEmpty)
{
name = rootElementName.Name;
str2 = rootElementName.Namespace;
}
else
{
name = type.Name;
str2 = operation.DeclaringContract.Namespace;
}
}
else
{
XmlTypeMapping mapping = XmlReflectionImporter.ImportTypeMapping(type);
name = mapping.ElementName;
str2 = mapping.Namespace;
}
MessagePartDescription item = new MessagePartDescription(NamingHelper.XmlName(name), str2) {
Index = 0,
Type = type
};
message.Body.Parts.Add(item);
}
if (isResponse)
{
SetReturnValue(message, operation);
}
}
internal void AddMessage(MessageDescription messageDescription, WsdlNS.OperationMessage wsdlOperationMessage)
{
this.wsdlOperationMessages.Add(messageDescription, wsdlOperationMessage);
this.messageDescriptions.Add(wsdlOperationMessage, messageDescription);
}
public OperationMessage GetOperationMessage(
MessageDescription message)
{
throw new NotImplementedException();
}
ContractDescription DoImportContract(PortType wsdlPortType)
{
BeforeImport();
ContractDescription cd = new ContractDescription(wsdlPortType.Name, wsdlPortType.ServiceDescription.TargetNamespace);
foreach (Operation op in wsdlPortType.Operations)
{
OperationDescription op_descr = new OperationDescription(op.Name, cd);
foreach (OperationMessage opmsg in op.Messages)
{
/* OperationMessageCollection */
MessageDescription msg_descr;
MessageDirection dir = MessageDirection.Input;
string action = "";
if (opmsg.GetType() == typeof(OperationInput))
{
dir = MessageDirection.Input;
}
else if (opmsg.GetType() == typeof(OperationOutput))
{
dir = MessageDirection.Output;
}
/* FIXME: OperationFault--> OperationDescription.Faults ? */
if (opmsg.ExtensibleAttributes != null)
{
for (int i = 0; i < opmsg.ExtensibleAttributes.Length; i++)
{
if (opmsg.ExtensibleAttributes [i].LocalName == "Action" &&
opmsg.ExtensibleAttributes [i].NamespaceURI == "http://www.w3.org/2006/05/addressing/wsdl")
{
/* addressing:Action */
action = opmsg.ExtensibleAttributes [i].Value;
}
/* FIXME: other attributes ? */
}
}
// fill Action from operation binding if required.
if (action == "")
{
if (dir != MessageDirection.Input)
{
action = GetActionFromOperationBinding(wsdlPortType, op.Name);
}
else
{
action = "*";
}
}
msg_descr = new MessageDescription(action, dir);
/* FIXME: Headers ? */
op_descr.Messages.Add(msg_descr);
}
cd.Operations.Add(op_descr);
}
WsdlContractConversionContext context = new WsdlContractConversionContext(cd, wsdlPortType);
foreach (IWsdlImportExtension extension in wsdl_extensions)
{
extension.ImportContract(this, context);
}
return(cd);
}
public override PolicyAssertionCollection GetMessageBindingAssertions(MessageDescription message)
{
return(s_noPolicy);
}
public MessageBinding GetMessageBinding(
MessageDescription message)
{
throw new NotImplementedException();
}
protected object DeserializeObject (XmlObjectSerializer serializer, Message message, MessageDescription md, bool isWrapped, WebContentFormat fmt)
{
// FIXME: handle ref/out parameters
var reader = message.GetReaderAtBodyContents ();
reader.MoveToContent ();
bool wasEmptyElement = reader.IsEmptyElement;
if (isWrapped) {
if (fmt == WebContentFormat.Json)
reader.ReadStartElement ("root", String.Empty); // note that the wrapper name is passed to the serializer.
else
reader.ReadStartElement (md.Body.WrapperName, md.Body.WrapperNamespace);
}
var ret = (serializer == null) ? null : ReadObjectBody (serializer, reader);
if (isWrapped && !wasEmptyElement)
reader.ReadEndElement ();
return ret;
}
private static OperationDescription GetCopyOfOperationDescription(OperationDescription other)
{
OperationDescription operationDecription = new OperationDescription(other.Name, other.DeclaringContract)
{
BeginMethod = other.BeginMethod,
EndMethod = other.EndMethod,
IsInitiating = other.IsInitiating,
IsTerminating = other.IsTerminating,
ProtectionLevel = other.ProtectionLevel,
SyncMethod = other.SyncMethod,
};
// copy Behaviors, Known Types, Faults
foreach (IOperationBehavior behavior in other.Behaviors)
{
operationDecription.Behaviors.Add(behavior);
}
foreach (Type knownType in other.KnownTypes)
{
operationDecription.KnownTypes.Add(knownType);
}
foreach (FaultDescription fault in other.Faults)
{
operationDecription.Faults.Add(fault);
}
// copy the Messages from the original OperationDescription
foreach (MessageDescription messageDescription in other.Messages)
{
MessageDescription newMessageDescription = new MessageDescription(messageDescription.Action, messageDescription.Direction);
operationDecription.Messages.Add(newMessageDescription);
}
return operationDecription;
}
public abstract PolicyAssertionCollection GetMessageBindingAssertions(MessageDescription message);
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);
bufferWriter.WriteEndElement();
bufferWriter.Flush();
XmlDocument doc = new XmlDocument();
memoryStream.Position = 0;
doc.Load(memoryStream);
//doc.Save(Console.Out);
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));
}
}
public static MessageDescription CreateMessageDescription(
OperationContractAttribute oca, ParameterInfo[] plist, string name, string defaultNamespace, string action, bool isRequest, bool isCallback, Type retType, ICustomAttributeProvider retTypeAttributes)
{
var dir = isRequest ^ isCallback ? MessageDirection.Input : MessageDirection.Output;
MessageDescription md = new MessageDescription(action, dir)
{
IsRequest = isRequest
};
MessageBodyDescription mb = md.Body;
mb.WrapperName = name + (isRequest ? String.Empty : "Response");
mb.WrapperNamespace = defaultNamespace;
if (oca.HasProtectionLevel)
{
md.ProtectionLevel = oca.ProtectionLevel;
}
// Parts
int index = 0;
foreach (ParameterInfo pi in plist)
{
// AsyncCallback and state are extraneous.
if (oca.AsyncPattern && pi.Position == plist.Length - 2)
{
break;
}
// They are ignored:
// - out parameter in request
// - neither out nor ref parameter in reply
if (isRequest && pi.IsOut)
{
continue;
}
if (!isRequest && !pi.IsOut && !pi.ParameterType.IsByRef)
{
continue;
}
MessagePartDescription pd = CreatePartCore(GetMessageParameterAttribute(pi), pi.Name, defaultNamespace);
pd.Index = index++;
pd.Type = MessageFilterOutByRef(pi.ParameterType);
mb.Parts.Add(pd);
}
// ReturnValue
if (!isRequest)
{
MessagePartDescription mp = CreatePartCore(GetMessageParameterAttribute(retTypeAttributes), name + "Result", mb.WrapperNamespace);
mp.Index = 0;
mp.Type = retType;
mb.ReturnValue = mp;
}
// FIXME: fill properties.
return(md);
}
public static MessageDescription CreateMessageDescription(
Type messageType, string defaultNamespace, string action, bool isRequest, bool isCallback, MessageContractAttribute mca)
{
MessageDescription md = new MessageDescription(action, isRequest ^ isCallback ? MessageDirection.Input : MessageDirection.Output)
{
IsRequest = isRequest
};
md.MessageType = MessageFilterOutByRef(messageType);
if (mca.HasProtectionLevel)
{
md.ProtectionLevel = mca.ProtectionLevel;
}
MessageBodyDescription mb = md.Body;
if (mca.IsWrapped)
{
mb.WrapperName = mca.WrapperName ?? messageType.Name;
mb.WrapperNamespace = mca.WrapperNamespace ?? defaultNamespace;
}
int index = 0;
foreach (MemberInfo bmi in messageType.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
Type mtype = null;
string mname = null;
if (bmi is FieldInfo)
{
FieldInfo fi = (FieldInfo)bmi;
mtype = fi.FieldType;
mname = fi.Name;
}
else if (bmi is PropertyInfo)
{
PropertyInfo pi = (PropertyInfo)bmi;
mtype = pi.PropertyType;
mname = pi.Name;
}
else
{
continue;
}
var mha = bmi.GetCustomAttribute <MessageHeaderAttribute> (false);
if (mha != null)
{
var pd = CreateHeaderDescription(mha, mname, defaultNamespace);
pd.Type = MessageFilterOutByRef(mtype);
pd.MemberInfo = bmi;
md.Headers.Add(pd);
}
var mba = GetMessageBodyMemberAttribute(bmi);
if (mba != null)
{
var pd = CreatePartCore(mba, mname, defaultNamespace);
if (pd.Index <= 0)
{
pd.Index = index++;
}
pd.Type = MessageFilterOutByRef(mtype);
pd.MemberInfo = bmi;
mb.Parts.Add(pd);
}
}
// FIXME: fill headers and properties.
return(md);
}
public WsdlNS.OperationMessage GetOperationMessage(MessageDescription message)
{
return(this.wsdlOperationMessages[message]);
}
public System.Web.Services.Description.MessageBinding GetMessageBinding(MessageDescription message)
{
return(default(System.Web.Services.Description.MessageBinding));
}
void CreateInputBinding (ServiceEndpoint endpoint, OperationBinding op_binding,
MessageDescription sm_md)
{
var in_binding = new InputBinding ();
op_binding.Input = in_binding;
var message_version = endpoint.Binding.MessageVersion ?? MessageVersion.None;
if (message_version == MessageVersion.None)
return;
SoapBodyBinding soap_body_binding;
SoapOperationBinding soap_operation_binding;
if (message_version.Envelope == EnvelopeVersion.Soap11) {
soap_body_binding = new SoapBodyBinding ();
soap_operation_binding = new SoapOperationBinding ();
} else if (message_version.Envelope == EnvelopeVersion.Soap12) {
soap_body_binding = new Soap12BodyBinding ();
soap_operation_binding = new Soap12OperationBinding ();
} else {
throw new InvalidOperationException ();
}
soap_body_binding.Use = SoapBindingUse.Literal;
in_binding.Extensions.Add (soap_body_binding);
//Set Action
//<operation > <soap:operation soapAction .. >
soap_operation_binding.SoapAction = sm_md.Action;
soap_operation_binding.Style = SoapBindingStyle.Document;
op_binding.Extensions.Add (soap_operation_binding);
}
protected override object DeserializeBody(XmlDictionaryReader reader, MessageVersion version, string action, MessageDescription messageDescription, object[] parameters, bool isRequest)
{
MessageInfo messageInfo;
if (isRequest)
messageInfo = _requestMessageInfo;
else
messageInfo = _replyMessageInfo;
if (messageInfo.RpcEncodedTypedMessageBodyParts == null)
return DeserializeBody(reader, version, messageInfo.BodySerializer, messageDescription.Body.ReturnValue, messageDescription.Body.Parts, parameters, isRequest);
object[] bodyPartValues = new object[messageInfo.RpcEncodedTypedMessageBodyParts.Count];
DeserializeBody(reader, version, messageInfo.BodySerializer, null/*returnPart*/, messageInfo.RpcEncodedTypedMessageBodyParts, bodyPartValues, isRequest);
object bodyObject = Activator.CreateInstance(messageDescription.Body.Parts[0].Type);
int i = 0;
foreach (MessagePartDescription bodyPart in messageInfo.RpcEncodedTypedMessageBodyParts)
{
MemberInfo member = bodyPart.MemberInfo;
FieldInfo field = member as FieldInfo;
if (field != null)
field.SetValue(bodyObject, bodyPartValues[i++]);
else
{
PropertyInfo property = member as PropertyInfo;
if (property != null)
property.SetValue(bodyObject, bodyPartValues[i++], null);
}
}
parameters[messageDescription.Body.Parts[0].Index] = bodyObject;
return null;
}
public override PolicyAssertionCollection GetMessageBindingAssertions(MessageDescription message)
{
return(this.messageBindingAssertions[message]);
}
void ValidateExistingOrSetNewProtectionLevel(MessagePartDescription part, MessageDescription message, OperationDescription operation, ContractDescription contract, ProtectionLevel newProtectionLevel)
{
ProtectionLevel existingProtectionLevel;
if (part != null && part.HasProtectionLevel)
{
existingProtectionLevel = part.ProtectionLevel;
}
else if (message.HasProtectionLevel)
{
existingProtectionLevel = message.ProtectionLevel;
}
else if (operation.HasProtectionLevel)
{
existingProtectionLevel = operation.ProtectionLevel;
}
else
{
if (part != null)
{
part.ProtectionLevel = newProtectionLevel;
}
else
{
message.ProtectionLevel = newProtectionLevel;
}
existingProtectionLevel = newProtectionLevel;
}
if (existingProtectionLevel != newProtectionLevel)
{
if (part != null && !part.HasProtectionLevel)
{
part.ProtectionLevel = newProtectionLevel;
}
else if (part == null && !message.HasProtectionLevel)
{
message.ProtectionLevel = newProtectionLevel;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.CannotImportProtectionLevelForContract, contract.Name, contract.Namespace)));
}
}
}
public System.Web.Services.Description.OperationMessage GetOperationMessage(MessageDescription message)
{
return(default(System.Web.Services.Description.OperationMessage));
}
/// <summary>
/// Adds the preflight operations.
/// </summary>
/// <param name="endpoint">The endpoint.</param>
/// <param name="corsOperations">The cors operations.</param>
private void AddPreflightOperations(ServiceEndpoint endpoint, List<OperationDescription> corsOperations)
{
Dictionary<string, PreflightOperationBehavior> uriTemplates = new Dictionary<string, PreflightOperationBehavior>(StringComparer.OrdinalIgnoreCase);
foreach (var operation in corsOperations)
{
if ((operation.Behaviors.Find<WebGetAttribute>() != null) || (operation.IsOneWay))
{
continue;
}
string originalUriTemplate;
WebInvokeAttribute originalWia = operation.Behaviors.Find<WebInvokeAttribute>();
if (originalWia != null && originalWia.UriTemplate != null)
{
originalUriTemplate = NormalizeTemplate(originalWia.UriTemplate);
}
else
{
originalUriTemplate = operation.Name;
}
string originalMethod = originalWia != null && originalWia.Method != null ? originalWia.Method : "POST";
if (uriTemplates.ContainsKey(originalUriTemplate))
{
PreflightOperationBehavior operationBehavior = uriTemplates[originalUriTemplate];
operationBehavior.AddAllowedMethod(originalMethod);
}
else
{
ContractDescription contract = operation.DeclaringContract;
OperationDescription preflightOperation = new OperationDescription(operation.Name + CorsConstants.PreflightSuffix, contract);
MessageDescription inputMessage = new MessageDescription(operation.Messages[0].Action + CorsConstants.PreflightSuffix, MessageDirection.Input);
inputMessage.Body.Parts.Add(new MessagePartDescription("input", contract.Namespace) { Index = 0, Type = typeof(Message) });
preflightOperation.Messages.Add(inputMessage);
MessageDescription outputMessage = new MessageDescription(operation.Messages[1].Action + CorsConstants.PreflightSuffix, MessageDirection.Output);
outputMessage.Body.ReturnValue = new MessagePartDescription(preflightOperation.Name + "Return", contract.Namespace) { Type = typeof(Message) };
preflightOperation.Messages.Add(outputMessage);
WebInvokeAttribute wia = new WebInvokeAttribute();
wia.UriTemplate = originalUriTemplate;
wia.Method = "OPTIONS";
preflightOperation.Behaviors.Add(wia);
preflightOperation.Behaviors.Add(new DataContractSerializerOperationBehavior(preflightOperation));
PreflightOperationBehavior preflightOperationBehavior = new PreflightOperationBehavior(preflightOperation);
preflightOperationBehavior.AddAllowedMethod(originalMethod);
preflightOperationBehavior.AddAllowedMethod("DELETE");
preflightOperation.Behaviors.Add(preflightOperationBehavior);
uriTemplates.Add(originalUriTemplate, preflightOperationBehavior);
contract.Operations.Add(preflightOperation);
}
}
}
public override PolicyAssertionCollection GetMessageBindingAssertions(MessageDescription message)
{
throw new NotImplementedException();
}
void CreateOutputBinding (ServiceEndpoint endpoint, OperationBinding op_binding,
MessageDescription sm_md)
{
var out_binding = new OutputBinding ();
op_binding.Output = out_binding;
var message_version = endpoint.Binding.MessageVersion ?? MessageVersion.None;
if (message_version == MessageVersion.None)
return;
SoapBodyBinding soap_body_binding;
if (message_version.Envelope == EnvelopeVersion.Soap11) {
soap_body_binding = new SoapBodyBinding ();
} else if (message_version.Envelope == EnvelopeVersion.Soap12) {
soap_body_binding = new Soap12BodyBinding ();
} else {
throw new InvalidOperationException ();
}
soap_body_binding.Use = SoapBindingUse.Literal;
out_binding.Extensions.Add (soap_body_binding);
}
GetMessageBindingAssertions(MessageDescription message);
public override PolicyAssertionCollection GetMessageBindingAssertions(MessageDescription message)
{
lock (this.messageBindingAssertions)
{
if (!this.messageBindingAssertions.ContainsKey(message))
{
this.messageBindingAssertions.Add(message, new PolicyAssertionCollection());
}
}
return this.messageBindingAssertions[message];
}
void DoImportContract()
{
PortType port_type = context.WsdlPortType;
ContractDescription contract = context.Contract;
int i, j;
List <MessagePartDescription> parts = new List <MessagePartDescription> ();
i = 0;
foreach (Operation op in port_type.Operations)
{
OperationDescription opdescr = contract.Operations [i];
if (IsOperationImported(port_type, op))
{
continue;
}
if (!CanImportOperation(port_type, op))
{
continue;
}
j = 0;
foreach (OperationMessage opmsg in op.Messages)
{
//SM.MessageDescription
MessageDescription msgdescr = opdescr.Messages [j];
//OpMsg's corresponding WSMessage
Message msg = port_type.ServiceDescription.Messages [opmsg.Message.Name];
msgdescr.Body.WrapperNamespace = port_type.ServiceDescription.TargetNamespace;
if (opmsg is OperationOutput)
{
//ReturnValue
msg = port_type.ServiceDescription.Messages [opmsg.Message.Name];
resolveMessage(msg, msgdescr.Body, parts);
if (parts.Count > 0)
{
msgdescr.Body.ReturnValue = parts [0];
parts.Clear();
}
continue;
}
/* OperationInput */
/* Parts, MessagePartDescription */
resolveMessage(msg, msgdescr.Body, parts);
foreach (MessagePartDescription p in parts)
{
msgdescr.Body.Parts.Add(p);
}
parts.Clear();
j++;
}
OnOperationImported(opdescr);
i++;
}
}