private void ValidateMessagePartDescription(MessagePartDescription part)
{
if (part != null)
{
this.ValidateCustomSerializableType(part.Type);
}
}
/// <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);
}
private XmlReflectionMember CreateReflectionMember (MessagePartDescription partDesc, bool isReturnValue)
{
XmlReflectionMember m = new XmlReflectionMember ();
m.IsReturnValue = isReturnValue;
m.MemberName = partDesc.Name;
m.MemberType = partDesc.Type;
return m;
}
internal void Add(MessagePartDescription part, XmlMemberMapping memberMapping, XmlMembersMapping membersMapping, bool isEncoded)
{
PartInfo partInfo = new PartInfo();
partInfo.MemberMapping = memberMapping;
partInfo.MembersMapping = membersMapping;
partInfo.IsEncoded = isEncoded;
partInfoTable[part] = partInfo;
}
private XmlReflectionMember CreateReflectionMember (MessagePartDescription partDesc, bool isReturnValue)
{
XmlReflectionMember m = new XmlReflectionMember ();
m.IsReturnValue = isReturnValue;
m.MemberName = partDesc.Name;
m.MemberType = partDesc.Type;
m.XmlAttributes = partDesc.MemberInfo == null ? new XmlAttributes () : new XmlAttributes (partDesc.MemberInfo);
return m;
}
public RequestMessagePartDescription(MessagePartDescription messagePart, MessagePartType partType, string alias)
: base(messagePart.Name, messagePart.Namespace)
{
Index = messagePart.Index;
MemberInfo = messagePart.MemberInfo;
Multiple = messagePart.Multiple;
ProtectionLevel = messagePart.ProtectionLevel;
Type = messagePart.Type;
Alias = alias;
PartType = partType;
}
internal static XmlReflectionMember GetXmlReflectionMember(MessagePartDescription part, bool isRpc, bool isEncoded, bool isWrapped)
{
string ns = isRpc ? null : part.Namespace;
ICustomAttributeProvider additionalAttributesProvider = null;
if (isEncoded || (part.AdditionalAttributesProvider is MemberInfo))
{
additionalAttributesProvider = part.AdditionalAttributesProvider;
}
System.ServiceModel.Description.XmlName memberName = string.IsNullOrEmpty(part.UniquePartName) ? null : new System.ServiceModel.Description.XmlName(part.UniquePartName, true);
System.ServiceModel.Description.XmlName xmlName = part.XmlName;
return GetXmlReflectionMember(memberName, xmlName, ns, part.Type, additionalAttributesProvider, part.Multiple, isEncoded, isWrapped);
}
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;
}
internal MessagePartDescription(MessagePartDescription other)
{
this.name = other.name;
this.ns = other.ns;
this.index = other.index;
this.type = other.type;
this.serializationPosition = other.serializationPosition;
this.hasProtectionLevel = other.hasProtectionLevel;
this.protectionLevel = other.protectionLevel;
this.memberInfo = other.memberInfo;
this.multiple = other.multiple;
this.additionalAttributesProvider = other.additionalAttributesProvider;
this.baseType = other.baseType;
this.uniquePartName = other.uniquePartName;
}
internal MessagePartDescription(MessagePartDescription other)
{
_name = other._name;
_ns = other._ns;
_index = other._index;
_type = other._type;
_serializationPosition = other._serializationPosition;
_hasProtectionLevel = other._hasProtectionLevel;
_protectionLevel = other._protectionLevel;
_memberInfo = other._memberInfo;
_multiple = other._multiple;
_additionalAttributesProvider = other._additionalAttributesProvider;
_baseType = other._baseType;
_uniquePartName = other._uniquePartName;
}
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);
}
}
/// <summary>
/// Adds an item to the collection.
/// </summary>
/// <param name="item">The object to add to the collection.</param>
public void Add(HttpParameterDescription item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
if (this.IsSynchronized)
{
MessagePartDescription mpd = this.EnsureSynchronizedMessagePartDescription(item);
MessagePartDescriptionCollection mpdColl = this.GetOrCreateMessagePartDescriptionCollection();
mpdColl.Add(mpd);
}
else
{
this.innerCollection.Add(item);
}
}
public void AddMemberAttributes(XmlName messageName, MessagePartDescription part, CodeAttributeDeclarationCollection attributesImported, CodeAttributeDeclarationCollection typeAttributes, CodeAttributeDeclarationCollection fieldAttributes)
{
CodeAttributeDeclaration dataContractAttributeDecl = null;
foreach (CodeAttributeDeclaration attr in typeAttributes)
{
if (attr.AttributeType.BaseType == dataContractAttributeTypeRef.BaseType)
{
dataContractAttributeDecl = attr;
break;
}
}
if (dataContractAttributeDecl == null)
{
Fx.Assert(String.Format(CultureInfo.InvariantCulture, "Cannot find DataContract attribute for {0}", messageName));
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(String.Format(CultureInfo.InvariantCulture, "Cannot find DataContract attribute for {0}", messageName)));
}
bool nsAttrFound = false;
foreach (CodeAttributeArgument attrArg in dataContractAttributeDecl.Arguments)
{
if (attrArg.Name == "Namespace")
{
nsAttrFound = true;
string nsValue = ((CodePrimitiveExpression)attrArg.Value).Value.ToString();
if (nsValue != part.Namespace)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxWrapperTypeHasMultipleNamespaces, messageName)));
}
}
}
if (!nsAttrFound)
{
dataContractAttributeDecl.Arguments.Add(new CodeAttributeArgument("Namespace", new CodePrimitiveExpression(part.Namespace)));
}
DataMemberAttribute dataMemberAttribute = new DataMemberAttribute();
dataMemberAttribute.Order = memberCount++;
dataMemberAttribute.EmitDefaultValue = !IsNonNillableReferenceType(part);
fieldAttributes.Add(OperationGenerator.GenerateAttributeDeclaration(context.Contract.ServiceContractGenerator, dataMemberAttribute));
}
void AddKnownTypesForPart(OperationContractGenerationContext context, MessagePartDescription part, Dictionary <CodeTypeReference, object> operationKnownTypes)
{
ICollection <CodeTypeReference> knownTypesForPart;
if (knownTypes.TryGetValue(part, out knownTypesForPart))
{
foreach (CodeTypeReference knownTypeReference in knownTypesForPart)
{
object value;
if (!operationKnownTypes.TryGetValue(knownTypeReference, out value))
{
operationKnownTypes.Add(knownTypeReference, null);
CodeAttributeDeclaration knownTypeAttribute = new CodeAttributeDeclaration(typeof(ServiceKnownTypeAttribute).FullName);
knownTypeAttribute.Arguments.Add(new CodeAttributeArgument(new CodeTypeOfExpression(knownTypeReference)));
context.SyncMethod.CustomAttributes.Add(knownTypeAttribute);
}
}
}
}
XmlSchemaElement GetSchemaElementForPart(MessagePartDescription part, XmlSchema schema)
{
XmlSchemaElement element = new XmlSchemaElement();
element.Name = part.Name;
XsdExporter.Export(part.Type);
element.SchemaTypeName = XsdExporter.GetSchemaTypeName(part.Type);
AddImport(schema, element.SchemaTypeName.Namespace);
//FIXME: nillable, minOccurs
if (XsdExporter.GetSchemaType(part.Type) is XmlSchemaComplexType ||
part.Type == typeof(string))
{
element.IsNillable = true;
}
element.MinOccurs = 0;
return(element);
}
private void ExportDataContract(MessagePartDescription md)
{
if (data_contract_importer == null)
{
data_contract_importer = md.DataContractImporter;
}
else if (md.DataContractImporter != null && data_contract_importer != md.DataContractImporter)
{
throw new Exception("INTERNAL ERROR: should not happen");
}
if (xml_serialization_importer == null)
{
xml_serialization_importer = md.XmlSerializationImporter;
}
else if (md.XmlSerializationImporter != null && xml_serialization_importer != md.XmlSerializationImporter)
{
throw new Exception("INTERNAL ERROR: should not happen");
}
}
/* Sets the @name if the param or return type is SMMessage */
string IsTypeMessage(MessageBodyDescription msgbody)
{
MessagePartDescription part = null;
if (msgbody.Parts.Count == 0)
{
part = msgbody.ReturnValue;
}
else if (msgbody.Parts.Count == 1)
{
part = msgbody.Parts [0];
}
if (part != null && (part.Type.FullName == typeof(SMMessage).FullName))
{
return(part.Name);
}
return(null);
}
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);
}
}
/// <summary>
/// Determines the index of a specific item in the collection.
/// </summary>
/// <param name="item">The object to locate in the collection.</param>
/// <returns>The index of item if found in the list; otherwise, -1.</returns>
public int IndexOf(HttpParameterDescription item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
if (this.IsSynchronized)
{
MessagePartDescriptionCollection mpdColl = this.MessagePartDescriptionCollection;
if (mpdColl == null)
{
return(-1);
}
MessagePartDescription mpd = this.EnsureSynchronizedMessagePartDescription(item);
return(mpdColl.IndexOf(mpd));
}
return(this.innerCollection.IndexOf(item));
}
/// <summary>
/// Removes the first occurrence of a specific object from the collection.
/// </summary>
/// <param name="item">The object to remove from the collection.</param>
/// <returns><c>true</c> if <paramref name="item"/> was successfully removed from the collection; otherwise, <c>false</c>.
/// This method also returns <c>false</c> if <paramref name="item"/> is not found in the original collection.</returns>
public bool Remove(HttpParameterDescription item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
if (this.IsSynchronized)
{
MessagePartDescriptionCollection mdpColl = this.MessagePartDescriptionCollection;
if (mdpColl == null)
{
return(false);
}
MessagePartDescription mpd = this.EnsureSynchronizedMessagePartDescription(item);
return(mdpColl.Remove(mpd));
}
return(this.innerCollection.Remove(item));
}
public void AddMemberAttributes(XmlName messageName, MessagePartDescription part, CodeAttributeDeclarationCollection attributesImported, CodeAttributeDeclarationCollection typeAttributes, CodeAttributeDeclarationCollection fieldAttributes)
{
CodeAttributeDeclaration declaration = null;
foreach (CodeAttributeDeclaration declaration2 in typeAttributes)
{
if (declaration2.AttributeType.BaseType == dataContractAttributeTypeRef.BaseType)
{
declaration = declaration2;
break;
}
}
if (declaration == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(string.Format(CultureInfo.InvariantCulture, "Cannot find DataContract attribute for {0}", new object[] { messageName })));
}
bool flag = false;
foreach (CodeAttributeArgument argument in declaration.Arguments)
{
if (argument.Name == "Namespace")
{
flag = true;
if (((CodePrimitiveExpression)argument.Value).Value.ToString() != part.Namespace)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxWrapperTypeHasMultipleNamespaces", new object[] { messageName })));
}
}
}
if (!flag)
{
declaration.Arguments.Add(new CodeAttributeArgument("Namespace", new CodePrimitiveExpression(part.Namespace)));
}
DataMemberAttribute attribute = new DataMemberAttribute {
Order = this.memberCount++,
EmitDefaultValue = !this.IsNonNillableReferenceType(part)
};
fieldAttributes.Add(OperationGenerator.GenerateAttributeDeclaration(this.context.Contract.ServiceContractGenerator, attribute));
}
protected void ExportMessagePart(Message message, MessagePartDescription part, XmlQualifiedName typeName, XmlSchemaType xsdType, bool isOptional, bool isNillable, bool skipSchemaExport, bool generateElement, string wrapperNs, XmlSchemaSequence wrapperSequence, XmlSchemaSet schemaSet)
{
if (!IsNullOrEmpty(typeName) || (xsdType != null))
{
string name = part.Name;
string elementName = string.IsNullOrEmpty(part.UniquePartName) ? name : part.UniquePartName;
MessagePart part2 = null;
if (generateElement)
{
if (wrapperSequence != null)
{
if (!skipSchemaExport)
{
this.ExportLocalElement(wrapperNs, elementName, part.Namespace, typeName, xsdType, part.Multiple, isOptional, isNillable, wrapperSequence, schemaSet);
}
}
else
{
if (!skipSchemaExport)
{
this.ExportGlobalElement(name, part.Namespace, isNillable, typeName, xsdType, schemaSet);
}
part2 = AddMessagePart(message, elementName, new XmlQualifiedName(name, part.Namespace), XmlQualifiedName.Empty);
}
}
else
{
if (string.IsNullOrEmpty(typeName.Name))
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxAnonymousTypeNotSupported", new object[] { message.Name, elementName })));
}
part2 = AddMessagePart(message, elementName, XmlQualifiedName.Empty, typeName);
}
if (part2 != null)
{
part.UniquePartName = part2.Name;
}
}
}
private MessagePartDescription GetWrapperPart(MessageDescription message)
{
if (message.Body.Parts.Count != 1)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxRpcMessageMustHaveASingleBody", new object[] { this.Operation.Name, message.MessageName })));
}
MessagePartDescription description = message.Body.Parts[0];
System.Type c = description.Type;
if ((c.BaseType != null) && (c.BaseType != typeof(object)))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxBodyObjectTypeCannotBeInherited", new object[] { c.FullName })));
}
if (typeof(IEnumerable).IsAssignableFrom(c))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxBodyObjectTypeCannotBeInterface", new object[] { c.FullName, typeof(IEnumerable).FullName })));
}
if (typeof(IXmlSerializable).IsAssignableFrom(c))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxBodyObjectTypeCannotBeInterface", new object[] { c.FullName, typeof(IXmlSerializable).FullName })));
}
return(description);
}
/// <summary>
/// Determines whether the collection contains a specific value.
/// </summary>
/// <param name="item">The object to locate in the collection.</param>
/// <returns><c>true</c> if item is found in the collection; otherwise, <c>false</c>.</returns>
public bool Contains(HttpParameterDescription item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
if (this.IsSynchronized)
{
MessagePartDescriptionCollection mdpColl = this.MessagePartDescriptionCollection;
if (mdpColl == null)
{
return(false);
}
// Strategy: use the knowledge we would have wrapped the MessagePartDescription in the
// past when we released this HttpParameterDescription.
MessagePartDescription mpd = this.EnsureSynchronizedMessagePartDescription(item);
return(mdpColl.Contains(mpd));
}
return(this.innerCollection.Contains(item));
}
/// <summary>
/// Inserts an item at the specified index.
/// </summary>
/// <param name="index">The zero-based index at which item should be inserted.</param>
/// <param name="item">The object to insert at the specified index.</param>
public void Insert(int index, HttpParameterDescription item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
if (index < 0 || (index > this.Count))
{
throw new ArgumentOutOfRangeException("index");
}
if (this.IsSynchronized)
{
MessagePartDescription mpd = this.EnsureSynchronizedMessagePartDescription(item);
MessagePartDescriptionCollection mpdColl = this.GetOrCreateMessagePartDescriptionCollection();
Debug.Assert(mpdColl != null, "MessagePartDescriptionCollection cannot be null");
mpdColl.Insert(index, mpd);
}
else
{
this.innerCollection.Insert(index, item);
}
}
private void SerializeBody(XmlDictionaryWriter writer, MessageVersion version, XmlSerializer serializer, MessagePartDescription returnPart, MessagePartDescriptionCollection bodyParts, object returnValue, object[] parameters)
{
if (serializer == null)
{
return;
}
bool hasReturnValue = IsValidReturnValue(returnPart);
object[] bodyParameters = new object[bodyParts.Count + (hasReturnValue ? 1 : 0)];
int paramIndex = 0;
if (hasReturnValue)
bodyParameters[paramIndex++] = returnValue;
for (int i = 0; i < bodyParts.Count; i++)
bodyParameters[paramIndex++] = parameters[bodyParts[i].Index];
serializer.Serialize(writer, bodyParameters, null);
}
static internal XmlReflectionMember GetXmlReflectionMember(MessagePartDescription part, bool isRpc, bool isWrapped)
{
string ns = isRpc ? null : part.Namespace;
MemberInfo additionalAttributesProvider = null;
if (part.AdditionalAttributesProvider.MemberInfo != null)
additionalAttributesProvider = part.AdditionalAttributesProvider.MemberInfo;
XmlName memberName = string.IsNullOrEmpty(part.UniquePartName) ? null : new XmlName(part.UniquePartName, true /*isEncoded*/);
XmlName elementName = part.XmlName;
return GetXmlReflectionMember(memberName, elementName, ns, part.Type, additionalAttributesProvider, part.Multiple, isWrapped);
}
private void AddKnownTypesForPart(OperationContractGenerationContext context, MessagePartDescription part, Dictionary <CodeTypeReference, object> operationKnownTypes)
{
ICollection <CodeTypeReference> is2;
if (this.knownTypes.TryGetValue(part, out is2))
{
foreach (CodeTypeReference reference in is2)
{
object obj2;
if (!operationKnownTypes.TryGetValue(reference, out obj2))
{
operationKnownTypes.Add(reference, null);
CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(typeof(ServiceKnownTypeAttribute).FullName);
declaration.Arguments.Add(new CodeAttributeArgument(new CodeTypeOfExpression(reference)));
context.SyncMethod.CustomAttributes.Add(declaration);
}
}
}
}
protected void ExportMessagePart(WsdlNS.Message message, MessagePartDescription part, XmlQualifiedName typeName, XmlSchemaType xsdType, bool isOptional, bool isNillable, bool skipSchemaExport, bool generateElement, string wrapperNs, XmlSchemaSequence wrapperSequence, XmlSchemaSet schemaSet)
{
if (IsNullOrEmpty(typeName) && xsdType == null)
return;
#if DEBUG
if (xsdType == null)
Fx.Assert(NamingHelper.IsValidNCName(typeName.Name), "Name value has to be a valid NCName.");
#endif
string elementName = part.Name;
string partName = string.IsNullOrEmpty(part.UniquePartName) ? elementName : part.UniquePartName;
WsdlNS.MessagePart wsdlPart = null;
if (generateElement)
{
if (wrapperSequence != null)
{
if (!skipSchemaExport)
ExportLocalElement(wrapperNs, partName, part.Namespace, typeName, xsdType, part.Multiple, isOptional, isNillable, wrapperSequence, schemaSet);
}
else
{
if (!skipSchemaExport)
ExportGlobalElement(elementName, part.Namespace, isNillable, typeName, xsdType, schemaSet);
wsdlPart = AddMessagePart(message, partName, new XmlQualifiedName(elementName, part.Namespace), XmlQualifiedName.Empty);
}
}
else
{
if (String.IsNullOrEmpty(typeName.Name))
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxAnonymousTypeNotSupported, message.Name, partName)));
wsdlPart = AddMessagePart(message, partName, XmlQualifiedName.Empty, typeName);
}
if (wsdlPart != null)
{
part.UniquePartName = wsdlPart.Name;
}
}
/// <summary>
/// Validates the message part description.
/// </summary>
/// <param name="messagePartDescription">The message part description.</param>
private static void ValidateMessagePartDescription(MessagePartDescription messagePartDescription)
{
if (messagePartDescription != null)
{
ValidateJsonSerializableType(messagePartDescription.Type);
}
}
protected XmlObjectSerializer GetSerializer (WebContentFormat msgfmt, bool isWrapped, MessagePartDescription part)
{
if (part.Type == typeof (void))
return null; // no serialization should be done.
switch (msgfmt) {
case WebContentFormat.Xml:
if (xml_serializer == null)
xml_serializer = isWrapped ? new DataContractSerializer (part.Type, part.Name, part.Namespace) : new DataContractSerializer (part.Type);
return xml_serializer;
case WebContentFormat.Json:
// FIXME: after name argument they are hack
if (json_serializer == null)
json_serializer = isWrapped ? new DataContractJsonSerializer (part.Type, BodyName ?? part.Name, null, 0x100000, false, null, true) : new DataContractJsonSerializer (part.Type);
return json_serializer;
default:
throw new NotImplementedException (msgfmt.ToString ());
}
}
void resolveParticle(XmlSchemaImporter schema_importer,
XmlSchemaParticle particle,
List <MessagePartDescription> parts,
string ns,
int depth)
{
if (particle is XmlSchemaGroupBase)
{
//sequence,
//FIXME: others?
if (depth <= 0)
{
return;
}
XmlSchemaGroupBase groupBase = particle as XmlSchemaGroupBase;
foreach (XmlSchemaParticle item in groupBase.Items)
{
resolveParticle(schema_importer, item, parts, ns, depth - 1);
}
return;
}
XmlSchemaElement elem = particle as XmlSchemaElement;
if (elem == null)
{
return;
}
MessagePartDescription msg_part = null;
XmlSchemaComplexType ct = elem.ElementSchemaType as XmlSchemaComplexType;
if (ct == null)
{
//Not a complex type
XmlSchemaSimpleType simple = elem.ElementSchemaType as XmlSchemaSimpleType;
msg_part = new MessagePartDescription(
elem.Name, ns);
if (elem.SchemaType != null)
{
msg_part.XmlTypeMapping = schema_importer.ImportTypeMapping(elem.QualifiedName);
}
else
{
msg_part.XmlTypeMapping = schema_importer.ImportSchemaType(elem.SchemaTypeName);
}
msg_part.TypeName = new QName(GetCLRTypeName(elem.SchemaTypeName), "");
parts.Add(msg_part);
return;
}
if (depth > 0)
{
resolveParticle(schema_importer, ct.ContentTypeParticle, parts, ns, depth - 1);
return;
}
//depth <= 0
msg_part = new MessagePartDescription(elem.Name, ns);
if (elem.SchemaType != null)
{
msg_part.XmlTypeMapping = schema_importer.ImportTypeMapping(elem.QualifiedName);
}
else
{
msg_part.XmlTypeMapping = schema_importer.ImportSchemaType(elem.SchemaTypeName);
}
msg_part.TypeName = elem.SchemaTypeName;
parts.Add(msg_part);
}
private static bool IsTypeSupported(MessagePartDescription bodyDescription)
{
Fx.Assert(bodyDescription != null, "");
Type type = bodyDescription.Type;
if (type == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxMessagePartDescriptionMissingType, bodyDescription.Name, bodyDescription.Namespace)));
if (bodyDescription.Multiple)
return false;
if (type == typeof(void))
return true;
if (type.IsEnum())
return false;
switch (type.GetTypeCode())
{
case TypeCode.Boolean:
case TypeCode.DateTime:
case TypeCode.Decimal:
case TypeCode.Double:
case TypeCode.Int32:
case TypeCode.Int64:
case TypeCode.Single:
case TypeCode.String:
return true;
case TypeCode.Object:
if (type.IsArray && type.GetArrayRank() == 1 && IsArrayTypeSupported(type.GetElementType()))
return true;
break;
default:
break;
}
return false;
}
private static PartInfo AddToDictionary(XmlDictionary dictionary, MessagePartDescription part, bool isRpc)
{
Type type = part.Type;
XmlDictionaryString itemName = null;
XmlDictionaryString itemNamespace = null;
if (type.IsArray && type != typeof(byte[]))
{
const string ns = "http://schemas.microsoft.com/2003/10/Serialization/Arrays";
string name = GetArrayItemName(type.GetElementType());
itemName = AddToDictionary(dictionary, name);
itemNamespace = AddToDictionary(dictionary, ns);
}
return new PartInfo(part,
AddToDictionary(dictionary, part.Name),
AddToDictionary(dictionary, isRpc ? string.Empty : part.Namespace),
itemName, itemNamespace);
}
/// <summary>
/// Create operation corresponding to given DomainService operation.
/// </summary>
/// <param name="declaringContract">Contract to which operation will belong.</param>
/// <param name="operation">DomainService operation.</param>
/// <returns>Created operation.</returns>
private static OperationDescription CreateOperationDescription(ContractDescription declaringContract, DomainOperationEntry operation)
{
OperationDescription operationDesc = new OperationDescription(operation.Name, declaringContract);
// Propagate behaviors.
foreach (IOperationBehavior behavior in operation.Attributes.OfType<IOperationBehavior>())
{
operationDesc.Behaviors.Add(behavior);
}
// Add standard web behaviors behaviors.
if ((operation.Operation == DomainOperation.Query && ((QueryAttribute)operation.OperationAttribute).HasSideEffects) ||
(operation.Operation == DomainOperation.Invoke && ((InvokeAttribute)operation.OperationAttribute).HasSideEffects))
{
// For operations with side-effects i.e. with WebInvoke attribute, we need to build a default GET like
// URI template so that, the parameter processing is taken care of by the WebHttpBehavior selector.
WebInvokeAttribute attrib = ServiceUtils.EnsureBehavior<WebInvokeAttribute>(operationDesc);
if (attrib.UriTemplate == null)
{
attrib.UriTemplate = ODataEndpointFactory.BuildDefaultUriTemplate(operation);
}
}
else
{
ServiceUtils.EnsureBehavior<WebGetAttribute>(operationDesc);
}
string action = ServiceUtils.GetRequestMessageAction(declaringContract, operationDesc.Name, null);
// Define operation input.
MessageDescription inputMessageDesc = new MessageDescription(action, MessageDirection.Input);
inputMessageDesc.Body.WrapperName = operationDesc.Name;
inputMessageDesc.Body.WrapperNamespace = ServiceUtils.DefaultNamespace;
for (int i = 0; i < operation.Parameters.Count; i++)
{
DomainOperationParameter parameter = operation.Parameters[i];
MessagePartDescription parameterPartDesc = new MessagePartDescription(parameter.Name, ServiceUtils.DefaultNamespace)
{
Index = i,
Type = TypeUtils.GetClientType(parameter.ParameterType)
};
inputMessageDesc.Body.Parts.Add(parameterPartDesc);
}
operationDesc.Messages.Add(inputMessageDesc);
// Define operation output.
string responseAction = ServiceUtils.GetResponseMessageAction(declaringContract, operationDesc.Name, null);
MessageDescription outputMessageDesc = new MessageDescription(responseAction, MessageDirection.Output);
outputMessageDesc.Body.WrapperName = operationDesc.Name + "Response";
outputMessageDesc.Body.WrapperNamespace = ServiceUtils.DefaultNamespace;
if (operation.ReturnType != typeof(void))
{
outputMessageDesc.Body.ReturnValue = new MessagePartDescription(operationDesc.Name + "Result", ServiceUtils.DefaultNamespace)
{
Type = TypeUtils.GetClientType(operation.ReturnType)
};
}
operationDesc.Messages.Add(outputMessageDesc);
return operationDesc;
}
public bool IsValidReturnValue (MessagePartDescription part)
{
return part != null && part.Type != typeof (void);
}
void WriteMessagePart (
XmlDictionaryWriter writer, MessageBodyDescription desc, MessagePartDescription partDesc, object obj)
{
parent.GetSerializer (partDesc).WriteObject (writer, obj);
}
XmlObjectSerializer GetSerializer (MessagePartDescription partDesc)
{
if (!serializers.ContainsKey (partDesc))
serializers [partDesc] = new DataContractSerializer (
partDesc.Type, partDesc.Name, partDesc.Namespace, OperationKnownTypes);
return serializers [partDesc];
}
static MessageDescription GetMessage(
OperationDescription od, MethodInfo mi,
OperationContractAttribute oca, bool isRequest,
bool isCallback, Type asyncReturnType)
{
ContractDescription cd = od.DeclaringContract;
ParameterInfo [] plist = mi.GetParameters();
Type messageType = null;
string action = isRequest ? oca.Action : oca.ReplyAction;
MessageContractAttribute mca;
Type retType = asyncReturnType;
if (!isRequest && retType == null)
{
retType = mi.ReturnType;
}
// If the argument is only one and has [MessageContract]
// then infer it as a typed messsage
if (isRequest)
{
int len = mi.Name.StartsWith("Begin", StringComparison.Ordinal) ? 3 : 1;
mca = plist.Length != len ? null :
GetMessageContractAttribute(plist [0].ParameterType);
if (mca != null)
{
messageType = plist [0].ParameterType;
}
}
else
{
mca = GetMessageContractAttribute(retType);
if (mca != null)
{
messageType = retType;
}
}
if (action == null)
{
action = String.Concat(cd.Namespace,
cd.Namespace.Length == 0 ? "urn:" : cd.Namespace.EndsWith("/") ? "" : "/", cd.Name, "/",
od.Name, isRequest ? String.Empty : "Response");
}
MessageDescription md;
if (mca != null)
{
md = CreateMessageDescription(messageType, cd.Namespace, action, isRequest, isCallback, mca);
}
else
{
md = CreateMessageDescription(oca, plist, od.Name, cd.Namespace, action, isRequest, isCallback, retType);
}
// ReturnValue
if (!isRequest)
{
MessagePartDescription mp = CreatePartCore(GetMessageParameterAttribute(mi.ReturnTypeCustomAttributes), od.Name + "Result", md.Body.WrapperNamespace);
mp.Index = 0;
mp.Type = mca != null ? typeof(void) : retType;
md.Body.ReturnValue = mp;
}
return(md);
}
private object DeserializeBody(XmlDictionaryReader reader, MessageVersion version, XmlSerializer serializer, MessagePartDescription returnPart, MessagePartDescriptionCollection bodyParts, object[] parameters, bool isRequest)
{
try
{
if (reader == null) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("reader"));
if (parameters == null) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("parameters"));
object returnValue = null;
if (serializer == null)
{
return null;
}
if (reader.NodeType == XmlNodeType.EndElement)
return null;
object[] bodyParameters = (object[])serializer.Deserialize(reader);
int paramIndex = 0;
if (IsValidReturnValue(returnPart))
returnValue = bodyParameters[paramIndex++];
for (int i = 0; i < bodyParts.Count; i++)
parameters[bodyParts[i].Index] = bodyParameters[paramIndex++];
return returnValue;
}
catch (InvalidOperationException e)
{
// all exceptions from XmlSerializer get wrapped in InvalidOperationException,
// so we must be conservative and never turn this into a fault
string resourceKey = isRequest ? SR.SFxErrorDeserializingRequestBody : SR.SFxErrorDeserializingReplyBody;
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
SR.Format(resourceKey, OperationName), e));
}
}
private void ExportDataContract (MessagePartDescription md)
{
if (data_contract_importer == null)
data_contract_importer = md.DataContractImporter;
else if (md.DataContractImporter != null && data_contract_importer != md.DataContractImporter)
throw new Exception ("INTERNAL ERROR: should not happen");
if (xml_serialization_importer == null)
xml_serialization_importer = md.XmlSerializationImporter;
else if (md.XmlSerializationImporter != null && xml_serialization_importer != md.XmlSerializationImporter)
throw new Exception ("INTERNAL ERROR: should not happen");
}
public PartInfo(MessagePartDescription description, XmlDictionaryString dictionaryName, XmlDictionaryString dictionaryNamespace, XmlDictionaryString itemName, XmlDictionaryString itemNamespace)
{
_dictionaryName = dictionaryName;
_dictionaryNamespace = dictionaryNamespace;
_itemName = itemName;
_itemNamespace = itemNamespace;
_description = description;
if (description.Type.IsArray)
{
_isArray = true;
_typeCode = description.Type.GetElementType().GetTypeCode();
}
else
{
_isArray = false;
_typeCode = description.Type.GetTypeCode();
}
}
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)));
}
}
}
private void GeneratePartType(Dictionary <XmlMembersMapping, XmlMembersMapping> alreadyExported, MessagePartDescription part)
{
if (this.partInfoTable.ContainsKey(part))
{
PartInfo info = this.partInfoTable[part];
XmlMembersMapping membersMapping = info.MembersMapping;
XmlMemberMapping memberMapping = info.MemberMapping;
if (!alreadyExported.ContainsKey(membersMapping))
{
if (info.IsEncoded)
{
this.SoapExporter.ExportMembersMapping(membersMapping);
}
else
{
this.XmlExporter.ExportMembersMapping(membersMapping);
}
alreadyExported.Add(membersMapping, membersMapping);
}
CodeAttributeDeclarationCollection metadata = new CodeAttributeDeclarationCollection();
if (info.IsEncoded)
{
this.SoapExporter.AddMappingMetadata(metadata, memberMapping, false);
}
else
{
this.XmlExporter.AddMappingMetadata(metadata, memberMapping, part.Namespace, false);
}
part.BaseType = this.GetTypeName(memberMapping);
this.operationGenerator.ParameterTypes.Add(part, new CodeTypeReference(part.BaseType));
this.operationGenerator.ParameterAttributes.Add(part, metadata);
}
}
/// <summary>
/// Validate message part description
/// </summary>
/// <param name="pd"></param>
private void ValidateMessagePartDescription(MessagePartDescription pd)
{
if (pd != null)
this.ValidateIsIGraphable(pd.Type);
}
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);
}
XmlSchemaElement GetSchemaElementForPart (MessagePartDescription part, XmlSchema schema)
{
XmlSchemaElement element = new XmlSchemaElement ();
element.Name = part.Name;
XsdExporter.Export (part.Type);
element.SchemaTypeName = XsdExporter.GetSchemaTypeName (part.Type);
AddImport (schema, element.SchemaTypeName.Namespace);
//FIXME: nillable, minOccurs
if (XsdExporter.GetSchemaType (part.Type) is XmlSchemaComplexType ||
part.Type == typeof (string))
element.IsNillable = true;
element.MinOccurs = 0;
return element;
}
private void GeneratePartType(Dictionary <XmlMembersMapping, XmlMembersMapping> alreadyExported, MessagePartDescription part, string partNamespace)
{
if (!partInfoTable.ContainsKey(part))
{
return;
}
PartInfo partInfo = partInfoTable[part];
XmlMembersMapping membersMapping = partInfo.MembersMapping;
XmlMemberMapping memberMapping = partInfo.MemberMapping;
if (!alreadyExported.ContainsKey(membersMapping))
{
if (partInfo.IsEncoded)
{
SoapExporter.ExportMembersMapping(membersMapping);
}
else
{
XmlExporter.ExportMembersMapping(membersMapping);
}
alreadyExported.Add(membersMapping, membersMapping);
}
CodeAttributeDeclarationCollection additionalAttributes = new CodeAttributeDeclarationCollection();
if (partInfo.IsEncoded)
{
SoapExporter.AddMappingMetadata(additionalAttributes, memberMapping, false /*forceUseMemberName*/);
}
else
{
XmlExporter.AddMappingMetadata(additionalAttributes, memberMapping, partNamespace, false /*forceUseMemberName*/);
}
part.BaseType = GetTypeName(memberMapping);
operationGenerator.ParameterTypes.Add(part, new CodeTypeReference(part.BaseType));
operationGenerator.ParameterAttributes.Add(part, additionalAttributes);
}