| | | 1 | | // Licensed to the .NET Foundation under one or more agreements. |
| | | 2 | | // The .NET Foundation licenses this file to you under the MIT license. |
| | | 3 | | |
| | | 4 | | using System; |
| | | 5 | | using System.Collections; |
| | | 6 | | using System.Collections.Generic; |
| | | 7 | | using System.Collections.ObjectModel; |
| | | 8 | | using System.Linq; |
| | | 9 | | using System.Reflection; |
| | | 10 | | using System.Xml; |
| | | 11 | | using System.Xml.Serialization; |
| | | 12 | | using CoreWCF.Channels; |
| | | 13 | | using CoreWCF.Collections.Generic; |
| | | 14 | | using CoreWCF.Dispatcher; |
| | | 15 | | using CoreWCF.Runtime; |
| | | 16 | | |
| | | 17 | | namespace CoreWCF.Description |
| | | 18 | | { |
| | | 19 | | public class XmlSerializerOperationBehavior : IOperationBehavior, IWsdlExportExtension |
| | | 20 | | { |
| | | 21 | | public XmlSerializerOperationBehavior(OperationDescription operation) |
| | 0 | 22 | | : this(operation, null) |
| | | 23 | | { |
| | 0 | 24 | | } |
| | | 25 | | |
| | 0 | 26 | | public XmlSerializerOperationBehavior(OperationDescription operation, XmlSerializerFormatAttribute attribute) |
| | | 27 | | { |
| | 0 | 28 | | if (operation == null) |
| | | 29 | | { |
| | 0 | 30 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(operation)); |
| | | 31 | | } |
| | | 32 | | |
| | 0 | 33 | | Reflector parentReflector = new Reflector(operation.DeclaringContract.Namespace, operation.DeclaringContract |
| | 0 | 34 | | OperationReflector = parentReflector.ReflectOperation(operation, attribute ?? new XmlSerializerFormatAttribu |
| | 0 | 35 | | } |
| | | 36 | | |
| | | 37 | | public XmlSerializerOperationBehavior(OperationDescription operation, XmlSerializerFormatAttribute attribute, st |
| | 0 | 38 | | : this(operation, attribute) |
| | | 39 | | { |
| | 0 | 40 | | OperationReflector = new Reflector(contractType, null).ReflectOperation(operation, attribute ?? new XmlSeria |
| | 0 | 41 | | } |
| | | 42 | | |
| | 52 | 43 | | private XmlSerializerOperationBehavior(Reflector.OperationReflector reflector, bool builtInOperationBehavior) |
| | | 44 | | { |
| | | 45 | | Fx.Assert(reflector != null, ""); |
| | 52 | 46 | | OperationReflector = reflector; |
| | 52 | 47 | | IsBuiltInOperationBehavior = builtInOperationBehavior; |
| | 52 | 48 | | } |
| | | 49 | | |
| | 411 | 50 | | internal Reflector.OperationReflector OperationReflector { get; } |
| | | 51 | | |
| | 0 | 52 | | internal bool IsBuiltInOperationBehavior { get; } |
| | | 53 | | |
| | | 54 | | public XmlSerializerFormatAttribute XmlSerializerFormatAttribute |
| | | 55 | | { |
| | | 56 | | get |
| | | 57 | | { |
| | 38 | 58 | | return OperationReflector.Attribute; |
| | | 59 | | } |
| | | 60 | | } |
| | | 61 | | |
| | | 62 | | internal static XmlSerializerOperationFormatter CreateOperationFormatter(OperationDescription operation) |
| | | 63 | | { |
| | 0 | 64 | | return new XmlSerializerOperationBehavior(operation).CreateFormatter(); |
| | | 65 | | } |
| | | 66 | | |
| | | 67 | | internal static XmlSerializerOperationFormatter CreateOperationFormatter(OperationDescription operation, XmlSeri |
| | | 68 | | { |
| | 0 | 69 | | return new XmlSerializerOperationBehavior(operation, attr).CreateFormatter(); |
| | | 70 | | } |
| | | 71 | | |
| | | 72 | | internal static void AddBehaviors(ContractDescription contract) |
| | | 73 | | { |
| | 0 | 74 | | AddBehaviors(contract, false); |
| | 0 | 75 | | } |
| | | 76 | | |
| | | 77 | | internal static void AddBuiltInBehaviors(ContractDescription contract) |
| | | 78 | | { |
| | 32 | 79 | | AddBehaviors(contract, true); |
| | 32 | 80 | | } |
| | | 81 | | |
| | | 82 | | private static void AddBehaviors(ContractDescription contract, bool builtInOperationBehavior) |
| | | 83 | | { |
| | 32 | 84 | | Reflector reflector = new Reflector(contract.Namespace, contract.ContractType); |
| | | 85 | | |
| | 184 | 86 | | foreach (OperationDescription operation in contract.Operations) |
| | | 87 | | { |
| | 60 | 88 | | Reflector.OperationReflector operationReflector = reflector.ReflectOperation(operation); |
| | 60 | 89 | | if (operationReflector != null) |
| | | 90 | | { |
| | 60 | 91 | | bool isInherited = operation.DeclaringContract != contract; |
| | 60 | 92 | | if (!isInherited) |
| | | 93 | | { |
| | 52 | 94 | | operation.Behaviors.Add(new XmlSerializerOperationBehavior(operationReflector, builtInOperationB |
| | | 95 | | //operation.Behaviors.Add(new XmlSerializerOperationGenerator(new XmlSerializerImportOptions())) |
| | | 96 | | } |
| | | 97 | | } |
| | | 98 | | } |
| | 32 | 99 | | } |
| | | 100 | | |
| | | 101 | | internal XmlSerializerOperationFormatter CreateFormatter() |
| | | 102 | | { |
| | 50 | 103 | | return new XmlSerializerOperationFormatter(OperationReflector.Operation, OperationReflector.Attribute, Opera |
| | | 104 | | } |
| | | 105 | | |
| | | 106 | | private XmlSerializerFaultFormatter CreateFaultFormatter(SynchronizedCollection<FaultContractInfo> faultContract |
| | | 107 | | { |
| | 5 | 108 | | return new XmlSerializerFaultFormatter(faultContractInfos, OperationReflector.XmlSerializerFaultContractInfo |
| | | 109 | | } |
| | | 110 | | |
| | | 111 | | void IOperationBehavior.Validate(OperationDescription description) |
| | | 112 | | { |
| | 50 | 113 | | } |
| | | 114 | | |
| | | 115 | | void IOperationBehavior.AddBindingParameters(OperationDescription description, BindingParameterCollection parame |
| | | 116 | | { |
| | 59 | 117 | | } |
| | | 118 | | |
| | | 119 | | void IOperationBehavior.ApplyDispatchBehavior(OperationDescription description, DispatchOperation dispatch) |
| | | 120 | | { |
| | 50 | 121 | | if (description == null) |
| | | 122 | | { |
| | 0 | 123 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(description)); |
| | | 124 | | } |
| | | 125 | | |
| | 50 | 126 | | if (dispatch == null) |
| | | 127 | | { |
| | 0 | 128 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(dispatch)); |
| | | 129 | | } |
| | | 130 | | |
| | 50 | 131 | | if (dispatch.Formatter == null) |
| | | 132 | | { |
| | 50 | 133 | | dispatch.Formatter = (IDispatchMessageFormatter)CreateFormatter(); |
| | 50 | 134 | | dispatch.DeserializeRequest = OperationReflector.RequestRequiresSerialization; |
| | 50 | 135 | | dispatch.SerializeReply = OperationReflector.ReplyRequiresSerialization; |
| | | 136 | | } |
| | | 137 | | |
| | 50 | 138 | | if (OperationReflector.Attribute.SupportFaults) |
| | | 139 | | { |
| | 5 | 140 | | if (!dispatch.IsFaultFormatterSetExplicit) |
| | | 141 | | { |
| | 5 | 142 | | dispatch.FaultFormatter = (IDispatchFaultFormatter)CreateFaultFormatter(dispatch.FaultContractInfos) |
| | | 143 | | } |
| | | 144 | | else |
| | | 145 | | { |
| | 0 | 146 | | if (dispatch.FaultFormatter is IDispatchFaultFormatterWrapper wrapper) |
| | | 147 | | { |
| | 0 | 148 | | wrapper.InnerFaultFormatter = (IDispatchFaultFormatter)CreateFaultFormatter(dispatch.FaultContra |
| | | 149 | | } |
| | | 150 | | } |
| | | 151 | | } |
| | 45 | 152 | | } |
| | | 153 | | |
| | | 154 | | void IOperationBehavior.ApplyClientBehavior(OperationDescription description, ClientOperation proxy) |
| | | 155 | | { |
| | 0 | 156 | | if (description == null) |
| | | 157 | | { |
| | 0 | 158 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(description)); |
| | | 159 | | } |
| | | 160 | | |
| | 0 | 161 | | if (proxy == null) |
| | | 162 | | { |
| | 0 | 163 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(proxy)); |
| | | 164 | | } |
| | | 165 | | |
| | 0 | 166 | | if (proxy.Formatter == null) |
| | | 167 | | { |
| | 0 | 168 | | proxy.Formatter = (IClientMessageFormatter)CreateFormatter(); |
| | 0 | 169 | | proxy.SerializeRequest = OperationReflector.RequestRequiresSerialization; |
| | 0 | 170 | | proxy.DeserializeReply = OperationReflector.ReplyRequiresSerialization; |
| | | 171 | | } |
| | | 172 | | |
| | 0 | 173 | | if (OperationReflector.Attribute.SupportFaults && !proxy.IsFaultFormatterSetExplicit) |
| | | 174 | | { |
| | 0 | 175 | | proxy.FaultFormatter = (IClientFaultFormatter)CreateFaultFormatter(proxy.FaultContractInfos); |
| | | 176 | | } |
| | 0 | 177 | | } |
| | | 178 | | |
| | | 179 | | void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext endpointContext) |
| | | 180 | | { |
| | 9 | 181 | | if (exporter == null) |
| | 0 | 182 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(exporter)); |
| | 9 | 183 | | if (endpointContext == null) |
| | 0 | 184 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(endpointContext)); |
| | | 185 | | |
| | 9 | 186 | | MessageContractExporter.ExportMessageBinding(exporter, endpointContext, typeof(XmlSerializerMessageContractE |
| | 9 | 187 | | } |
| | | 188 | | |
| | | 189 | | void IWsdlExportExtension.ExportContract(WsdlExporter exporter, WsdlContractConversionContext contractContext) |
| | | 190 | | { |
| | 9 | 191 | | if (exporter == null) |
| | 0 | 192 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(exporter)); |
| | 9 | 193 | | if (contractContext == null) |
| | 0 | 194 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(contractContext)); |
| | | 195 | | |
| | 9 | 196 | | new XmlSerializerMessageContractExporter(exporter, contractContext, OperationReflector.Operation, this).Expo |
| | 9 | 197 | | } |
| | | 198 | | |
| | | 199 | | public Collection<XmlMapping> GetXmlMappings() |
| | | 200 | | { |
| | 0 | 201 | | Collection<XmlMapping> mappings = new Collection<XmlMapping>(); |
| | 0 | 202 | | if (OperationReflector.Request != null && OperationReflector.Request.HeadersMapping != null) |
| | | 203 | | { |
| | 0 | 204 | | mappings.Add(OperationReflector.Request.HeadersMapping); |
| | | 205 | | } |
| | | 206 | | |
| | 0 | 207 | | if (OperationReflector.Request != null && OperationReflector.Request.BodyMapping != null) |
| | | 208 | | { |
| | 0 | 209 | | mappings.Add(OperationReflector.Request.BodyMapping); |
| | | 210 | | } |
| | | 211 | | |
| | 0 | 212 | | if (OperationReflector.Reply != null && OperationReflector.Reply.HeadersMapping != null) |
| | | 213 | | { |
| | 0 | 214 | | mappings.Add(OperationReflector.Reply.HeadersMapping); |
| | | 215 | | } |
| | | 216 | | |
| | 0 | 217 | | if (OperationReflector.Reply != null && OperationReflector.Reply.BodyMapping != null) |
| | | 218 | | { |
| | 0 | 219 | | mappings.Add(OperationReflector.Reply.BodyMapping); |
| | | 220 | | } |
| | | 221 | | |
| | 0 | 222 | | return mappings; |
| | | 223 | | } |
| | | 224 | | |
| | | 225 | | // helper for reflecting operations |
| | | 226 | | internal class Reflector |
| | | 227 | | { |
| | | 228 | | private readonly XmlSerializerImporter _importer; |
| | | 229 | | private readonly SerializerGenerationContext _generation; |
| | 34 | 230 | | private readonly Collection<OperationReflector> _operationReflectors = new Collection<OperationReflector>(); |
| | 34 | 231 | | private readonly object _thisLock = new object(); |
| | | 232 | | |
| | 34 | 233 | | internal Reflector(string defaultNs, Type type) |
| | | 234 | | { |
| | 34 | 235 | | _importer = new XmlSerializerImporter(defaultNs); |
| | 34 | 236 | | _generation = new SerializerGenerationContext(type); |
| | 34 | 237 | | } |
| | | 238 | | |
| | | 239 | | internal void EnsureMessageInfos() |
| | | 240 | | { |
| | 123 | 241 | | lock (_thisLock) |
| | | 242 | | { |
| | 940 | 243 | | foreach (OperationReflector operationReflector in _operationReflectors) |
| | | 244 | | { |
| | 347 | 245 | | operationReflector.EnsureMessageInfos(); |
| | | 246 | | } |
| | | 247 | | } |
| | 123 | 248 | | } |
| | | 249 | | |
| | | 250 | | private static XmlSerializerFormatAttribute FindAttribute(OperationDescription operation) |
| | | 251 | | { |
| | 69 | 252 | | Type contractType = operation.DeclaringContract?.ContractType; |
| | 69 | 253 | | XmlSerializerFormatAttribute contractFormatAttribute = contractType != null ? TypeLoader.GetFormattingAt |
| | 69 | 254 | | return TypeLoader.GetFormattingAttribute(operation.OperationMethod, contractFormatAttribute) as XmlSeria |
| | | 255 | | } |
| | | 256 | | |
| | | 257 | | // auto-reflects the operation, returning null if no attribute was found or inherited |
| | | 258 | | internal OperationReflector ReflectOperation(OperationDescription operation) |
| | | 259 | | { |
| | 69 | 260 | | XmlSerializerFormatAttribute attr = FindAttribute(operation); |
| | 69 | 261 | | if (attr == null) |
| | | 262 | | { |
| | 0 | 263 | | return null; |
| | | 264 | | } |
| | | 265 | | |
| | 69 | 266 | | return ReflectOperation(operation, attr); |
| | | 267 | | } |
| | | 268 | | |
| | | 269 | | // overrides the auto-reflection with an attribute |
| | | 270 | | internal OperationReflector ReflectOperation(OperationDescription operation, XmlSerializerFormatAttribute at |
| | | 271 | | { |
| | 69 | 272 | | OperationReflector operationReflector = new OperationReflector(this, operation, attrOverride, true/*refl |
| | 69 | 273 | | _operationReflectors.Add(operationReflector); |
| | | 274 | | |
| | 69 | 275 | | return operationReflector; |
| | | 276 | | } |
| | | 277 | | |
| | | 278 | | internal class OperationReflector |
| | | 279 | | { |
| | | 280 | | private readonly Reflector _parent; |
| | | 281 | | |
| | | 282 | | internal readonly OperationDescription Operation; |
| | | 283 | | internal readonly XmlSerializerFormatAttribute Attribute; |
| | | 284 | | |
| | | 285 | | internal readonly bool IsEncoded; |
| | | 286 | | internal readonly bool IsRpc; |
| | | 287 | | internal readonly bool IsOneWay; |
| | | 288 | | internal readonly bool RequestRequiresSerialization; |
| | | 289 | | internal readonly bool ReplyRequiresSerialization; |
| | | 290 | | private readonly string _keyBase; |
| | | 291 | | private MessageInfo _request; |
| | | 292 | | private MessageInfo _reply; |
| | | 293 | | private SynchronizedCollection<XmlSerializerFaultContractInfo> _xmlSerializerFaultContractInfos; |
| | | 294 | | |
| | 69 | 295 | | internal OperationReflector(Reflector parent, OperationDescription operation, XmlSerializerFormatAttribu |
| | | 296 | | { |
| | | 297 | | Fx.Assert(parent != null, ""); |
| | | 298 | | Fx.Assert(operation != null, ""); |
| | | 299 | | Fx.Assert(attr != null, ""); |
| | | 300 | | |
| | 69 | 301 | | OperationFormatter.Validate(operation, attr.Style == OperationFormatStyle.Rpc, attr.IsEncoded); |
| | | 302 | | |
| | 69 | 303 | | _parent = parent; |
| | | 304 | | |
| | 69 | 305 | | Operation = operation; |
| | 69 | 306 | | Attribute = attr; |
| | | 307 | | |
| | 69 | 308 | | IsEncoded = attr.IsEncoded; |
| | 69 | 309 | | IsRpc = (attr.Style == OperationFormatStyle.Rpc); |
| | 69 | 310 | | IsOneWay = operation.Messages.Count == 1; |
| | | 311 | | |
| | 69 | 312 | | RequestRequiresSerialization = !operation.Messages[0].IsUntypedMessage; |
| | 69 | 313 | | ReplyRequiresSerialization = !IsOneWay && !operation.Messages[1].IsUntypedMessage; |
| | | 314 | | |
| | 69 | 315 | | MethodInfo methodInfo = operation.OperationMethod; |
| | 69 | 316 | | if (methodInfo == null) |
| | | 317 | | { |
| | | 318 | | // keyBase needs to be unique within the scope of the parent reflector |
| | 0 | 319 | | _keyBase = string.Empty; |
| | 0 | 320 | | if (operation.DeclaringContract != null) |
| | | 321 | | { |
| | 0 | 322 | | _keyBase = operation.DeclaringContract.Name + "," + operation.DeclaringContract.Namespace + |
| | | 323 | | } |
| | 0 | 324 | | _keyBase = _keyBase + operation.Name; |
| | | 325 | | } |
| | | 326 | | else |
| | | 327 | | { |
| | 69 | 328 | | _keyBase = methodInfo.DeclaringType.FullName + ":" + methodInfo.ToString(); |
| | | 329 | | } |
| | | 330 | | |
| | 414 | 331 | | foreach (MessageDescription message in operation.Messages) |
| | | 332 | | { |
| | 284 | 333 | | foreach (MessageHeaderDescription header in message.Headers) |
| | | 334 | | { |
| | 4 | 335 | | SetUnknownHeaderInDescription(header); |
| | | 336 | | } |
| | | 337 | | } |
| | | 338 | | |
| | 69 | 339 | | if (!reflectOnDemand) |
| | | 340 | | { |
| | 0 | 341 | | EnsureMessageInfos(); |
| | | 342 | | } |
| | 69 | 343 | | } |
| | | 344 | | |
| | | 345 | | private void SetUnknownHeaderInDescription(MessageHeaderDescription header) |
| | | 346 | | { |
| | 4 | 347 | | if (IsEncoded) //XmlAnyElementAttribute does not apply |
| | | 348 | | { |
| | 0 | 349 | | return; |
| | | 350 | | } |
| | | 351 | | |
| | 4 | 352 | | if (header.AdditionalAttributesProvider != null) |
| | | 353 | | { |
| | 4 | 354 | | object[] attributes = header |
| | 4 | 355 | | .AdditionalAttributesProvider |
| | 4 | 356 | | .GetCustomAttributes(false) |
| | 4 | 357 | | .ToArray(); |
| | | 358 | | |
| | 4 | 359 | | bool isUnknown = false; |
| | 4 | 360 | | bool xmlIgnore = false; |
| | | 361 | | |
| | 16 | 362 | | foreach (object attribute in attributes) |
| | | 363 | | { |
| | 4 | 364 | | if (attribute is XmlAnyElementAttribute elementAttribute) |
| | | 365 | | { |
| | 0 | 366 | | if (string.IsNullOrEmpty(elementAttribute.Name)) |
| | | 367 | | { |
| | 0 | 368 | | isUnknown = true; |
| | | 369 | | } |
| | | 370 | | } |
| | | 371 | | |
| | | 372 | | // In the original full framework code using XmlAttributes, the XmlAnyElements collection is |
| | | 373 | | // if the XmlIgnore attribute is present. |
| | 4 | 374 | | if (attribute is XmlIgnoreAttribute) |
| | | 375 | | { |
| | 0 | 376 | | xmlIgnore = true; |
| | 0 | 377 | | break; // XmlIgnore overrides all so no need to continue if found. |
| | | 378 | | } |
| | | 379 | | } |
| | | 380 | | |
| | 4 | 381 | | header.IsUnknownHeaderCollection = isUnknown && !xmlIgnore; |
| | | 382 | | } |
| | 4 | 383 | | } |
| | | 384 | | |
| | | 385 | | private string ContractName |
| | | 386 | | { |
| | 2 | 387 | | get { return Operation.DeclaringContract.Name; } |
| | | 388 | | } |
| | | 389 | | |
| | | 390 | | private string ContractNamespace |
| | | 391 | | { |
| | 2 | 392 | | get { return Operation.DeclaringContract.Namespace; } |
| | | 393 | | } |
| | | 394 | | |
| | | 395 | | internal MessageInfo Request |
| | | 396 | | { |
| | | 397 | | get |
| | | 398 | | { |
| | 59 | 399 | | _parent.EnsureMessageInfos(); |
| | 59 | 400 | | return _request; |
| | | 401 | | } |
| | | 402 | | } |
| | | 403 | | |
| | | 404 | | internal MessageInfo Reply |
| | | 405 | | { |
| | | 406 | | get |
| | | 407 | | { |
| | 59 | 408 | | _parent.EnsureMessageInfos(); |
| | 59 | 409 | | return _reply; |
| | | 410 | | } |
| | | 411 | | } |
| | | 412 | | |
| | | 413 | | internal SynchronizedCollection<XmlSerializerFaultContractInfo> XmlSerializerFaultContractInfos |
| | | 414 | | { |
| | | 415 | | get |
| | | 416 | | { |
| | 5 | 417 | | _parent.EnsureMessageInfos(); |
| | 5 | 418 | | return _xmlSerializerFaultContractInfos; |
| | | 419 | | } |
| | | 420 | | } |
| | | 421 | | |
| | | 422 | | internal void EnsureMessageInfos() |
| | | 423 | | { |
| | 347 | 424 | | if (_request == null) |
| | | 425 | | { |
| | 166 | 426 | | foreach (Type knownType in Operation.KnownTypes) |
| | | 427 | | { |
| | 18 | 428 | | if (knownType == null) |
| | | 429 | | { |
| | 0 | 430 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException( |
| | | 431 | | } |
| | | 432 | | |
| | 18 | 433 | | _parent._importer.IncludeType(knownType, IsEncoded); |
| | | 434 | | } |
| | 65 | 435 | | _request = CreateMessageInfo(Operation.Messages[0], ":Request"); |
| | 65 | 436 | | if (_request != null && IsRpc && Operation.IsValidateRpcWrapperName && _request.BodyMapping.XsdE |
| | | 437 | | { |
| | 0 | 438 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.F |
| | | 439 | | } |
| | | 440 | | |
| | 65 | 441 | | if (!IsOneWay) |
| | | 442 | | { |
| | 65 | 443 | | _reply = CreateMessageInfo(Operation.Messages[1], ":Response"); |
| | 65 | 444 | | XmlName responseName = TypeLoader.GetBodyWrapperResponseName(Operation.Name); |
| | 65 | 445 | | if (_reply != null && IsRpc && Operation.IsValidateRpcWrapperName && _reply.BodyMapping.XsdE |
| | | 446 | | { |
| | 0 | 447 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException( |
| | | 448 | | } |
| | | 449 | | } |
| | 65 | 450 | | if (Attribute.SupportFaults) |
| | | 451 | | { |
| | 10 | 452 | | GenerateXmlSerializerFaultContractInfos(); |
| | | 453 | | } |
| | | 454 | | } |
| | 347 | 455 | | } |
| | | 456 | | |
| | | 457 | | private void GenerateXmlSerializerFaultContractInfos() |
| | | 458 | | { |
| | 10 | 459 | | SynchronizedCollection<XmlSerializerFaultContractInfo> faultInfos = new SynchronizedCollection<XmlSe |
| | 20 | 460 | | for (int i = 0; i < Operation.Faults.Count; i++) |
| | | 461 | | { |
| | 0 | 462 | | FaultDescription fault = Operation.Faults[i]; |
| | 0 | 463 | | FaultContractInfo faultContractInfo = new FaultContractInfo(fault.Action, fault.DetailType, faul |
| | | 464 | | |
| | 0 | 465 | | XmlMembersMapping xmlMembersMapping = ImportFaultElement(fault, out XmlQualifiedName elementName |
| | | 466 | | |
| | 0 | 467 | | SerializerStub serializerStub = _parent._generation.AddSerializer(xmlMembersMapping); |
| | 0 | 468 | | faultInfos.Add(new XmlSerializerFaultContractInfo(faultContractInfo, serializerStub, elementName |
| | | 469 | | } |
| | 10 | 470 | | _xmlSerializerFaultContractInfos = faultInfos; |
| | 10 | 471 | | } |
| | | 472 | | |
| | | 473 | | private MessageInfo CreateMessageInfo(MessageDescription message, string key) |
| | | 474 | | { |
| | 130 | 475 | | if (message.IsUntypedMessage) |
| | | 476 | | { |
| | 0 | 477 | | return null; |
| | | 478 | | } |
| | | 479 | | |
| | 130 | 480 | | MessageInfo info = new MessageInfo(); |
| | 130 | 481 | | if (message.IsTypedMessage) |
| | | 482 | | { |
| | 12 | 483 | | key = message.MessageType.FullName + ":" + IsEncoded + ":" + IsRpc; |
| | | 484 | | } |
| | | 485 | | |
| | 130 | 486 | | XmlMembersMapping headersMapping = LoadHeadersMapping(message, key + ":Headers"); |
| | 130 | 487 | | info.SetHeaders(_parent._generation.AddSerializer(headersMapping)); |
| | 130 | 488 | | info.SetBody(_parent._generation.AddSerializer(LoadBodyMapping(message, key, out MessagePartDescript |
| | 130 | 489 | | CreateHeaderDescriptionTable(message, info, headersMapping); |
| | 130 | 490 | | return info; |
| | | 491 | | } |
| | | 492 | | |
| | | 493 | | private void CreateHeaderDescriptionTable(MessageDescription message, MessageInfo info, XmlMembersMappin |
| | | 494 | | { |
| | 130 | 495 | | int headerNameIndex = 0; |
| | 130 | 496 | | OperationFormatter.MessageHeaderDescriptionTable headerDescriptionTable = new OperationFormatter.Mes |
| | 130 | 497 | | info.SetHeaderDescriptionTable(headerDescriptionTable); |
| | 268 | 498 | | foreach (MessageHeaderDescription header in message.Headers) |
| | | 499 | | { |
| | 4 | 500 | | if (header.IsUnknownHeaderCollection) |
| | | 501 | | { |
| | 0 | 502 | | info.SetUnknownHeaderDescription(header); |
| | | 503 | | } |
| | 4 | 504 | | else if (headersMapping != null) |
| | | 505 | | { |
| | 4 | 506 | | XmlMemberMapping memberMapping = headersMapping[headerNameIndex++]; |
| | | 507 | | string headerName, headerNs; |
| | 4 | 508 | | if (IsEncoded) |
| | | 509 | | { |
| | 0 | 510 | | headerName = memberMapping.TypeName; |
| | 0 | 511 | | headerNs = memberMapping.TypeNamespace; |
| | | 512 | | } |
| | | 513 | | else |
| | | 514 | | { |
| | 4 | 515 | | headerName = memberMapping.XsdElementName; |
| | 4 | 516 | | headerNs = memberMapping.Namespace; |
| | | 517 | | } |
| | 4 | 518 | | if (headerName != header.Name) |
| | | 519 | | { |
| | 0 | 520 | | if (message.MessageType != null) |
| | | 521 | | { |
| | 0 | 522 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationExcept |
| | | 523 | | } |
| | | 524 | | else |
| | | 525 | | { |
| | 0 | 526 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationExcept |
| | | 527 | | } |
| | | 528 | | } |
| | 4 | 529 | | if (headerNs != header.Namespace) |
| | | 530 | | { |
| | 0 | 531 | | if (message.MessageType != null) |
| | | 532 | | { |
| | 0 | 533 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationExcept |
| | | 534 | | } |
| | | 535 | | else |
| | | 536 | | { |
| | 0 | 537 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationExcept |
| | | 538 | | } |
| | | 539 | | } |
| | | 540 | | |
| | 4 | 541 | | headerDescriptionTable.Add(headerName, headerNs, header); |
| | | 542 | | } |
| | | 543 | | } |
| | 130 | 544 | | } |
| | | 545 | | |
| | | 546 | | private XmlMembersMapping LoadBodyMapping(MessageDescription message, string mappingKey, out MessagePart |
| | | 547 | | { |
| | | 548 | | MessagePartDescription returnPart; |
| | | 549 | | string wrapperName, wrapperNs; |
| | | 550 | | MessagePartDescriptionCollection bodyParts; |
| | 130 | 551 | | if (IsEncoded && message.IsTypedMessage && message.Body.WrapperName == null) |
| | | 552 | | { |
| | 0 | 553 | | MessagePartDescription wrapperPart = GetWrapperPart(message); |
| | 0 | 554 | | returnPart = null; |
| | 0 | 555 | | rpcEncodedTypedMessageBodyParts = bodyParts = GetWrappedParts(wrapperPart); |
| | 0 | 556 | | wrapperName = wrapperPart.Name; |
| | 0 | 557 | | wrapperNs = wrapperPart.Namespace; |
| | | 558 | | } |
| | | 559 | | else |
| | | 560 | | { |
| | 130 | 561 | | rpcEncodedTypedMessageBodyParts = null; |
| | 130 | 562 | | returnPart = OperationFormatter.IsValidReturnValue(message.Body.ReturnValue) ? message.Body.Retu |
| | 130 | 563 | | bodyParts = message.Body.Parts; |
| | 130 | 564 | | wrapperName = message.Body.WrapperName; |
| | 130 | 565 | | wrapperNs = message.Body.WrapperNamespace; |
| | | 566 | | } |
| | 130 | 567 | | bool isWrapped = (wrapperName != null); |
| | 130 | 568 | | bool hasReturnValue = returnPart != null; |
| | 130 | 569 | | int paramCount = bodyParts.Count + (hasReturnValue ? 1 : 0); |
| | 130 | 570 | | if (paramCount == 0 && !isWrapped) // no need to create serializer |
| | | 571 | | { |
| | 0 | 572 | | return null; |
| | | 573 | | } |
| | | 574 | | |
| | 130 | 575 | | XmlReflectionMember[] members = new XmlReflectionMember[paramCount]; |
| | 130 | 576 | | int paramIndex = 0; |
| | 130 | 577 | | if (hasReturnValue) |
| | | 578 | | { |
| | 59 | 579 | | members[paramIndex++] = XmlSerializerHelper.GetXmlReflectionMember(returnPart, IsRpc, IsEncoded, |
| | | 580 | | } |
| | | 581 | | |
| | 422 | 582 | | for (int i = 0; i < bodyParts.Count; i++) |
| | | 583 | | { |
| | 81 | 584 | | members[paramIndex++] = XmlSerializerHelper.GetXmlReflectionMember(bodyParts[i], IsRpc, IsEncode |
| | | 585 | | } |
| | | 586 | | |
| | 130 | 587 | | if (!isWrapped) |
| | | 588 | | { |
| | 0 | 589 | | wrapperNs = ContractNamespace; |
| | | 590 | | } |
| | | 591 | | |
| | 130 | 592 | | return ImportMembersMapping(wrapperName, wrapperNs, members, isWrapped, IsRpc, mappingKey); |
| | | 593 | | } |
| | | 594 | | |
| | | 595 | | private MessagePartDescription GetWrapperPart(MessageDescription message) |
| | | 596 | | { |
| | 0 | 597 | | if (message.Body.Parts.Count != 1) |
| | | 598 | | { |
| | 0 | 599 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Forma |
| | | 600 | | } |
| | | 601 | | |
| | 0 | 602 | | MessagePartDescription bodyPart = message.Body.Parts[0]; |
| | 0 | 603 | | Type bodyObjectType = bodyPart.Type; |
| | 0 | 604 | | if (bodyObjectType.GetTypeInfo().BaseType != null && bodyObjectType.GetTypeInfo().BaseType != typeof |
| | | 605 | | { |
| | 0 | 606 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Forma |
| | | 607 | | } |
| | | 608 | | |
| | 0 | 609 | | if (typeof(IEnumerable).IsAssignableFrom(bodyObjectType)) |
| | | 610 | | { |
| | 0 | 611 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Forma |
| | | 612 | | } |
| | | 613 | | |
| | 0 | 614 | | if (typeof(IXmlSerializable).IsAssignableFrom(bodyObjectType)) |
| | | 615 | | { |
| | 0 | 616 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Forma |
| | | 617 | | } |
| | | 618 | | |
| | 0 | 619 | | return bodyPart; |
| | | 620 | | } |
| | | 621 | | |
| | | 622 | | private MessagePartDescriptionCollection GetWrappedParts(MessagePartDescription bodyPart) |
| | | 623 | | { |
| | 0 | 624 | | Type bodyObjectType = bodyPart.Type; |
| | 0 | 625 | | MessagePartDescriptionCollection partList = new MessagePartDescriptionCollection(); |
| | 0 | 626 | | foreach (MemberInfo member in bodyObjectType.GetMembers(BindingFlags.Instance | BindingFlags.Public) |
| | | 627 | | { |
| | 0 | 628 | | if ((member as PropertyInfo) == null && (member as FieldInfo) == null) |
| | | 629 | | { |
| | | 630 | | continue; |
| | | 631 | | } |
| | | 632 | | |
| | 0 | 633 | | if (member.IsDefined(typeof(SoapIgnoreAttribute), inherit: false)) |
| | | 634 | | { |
| | | 635 | | continue; |
| | | 636 | | } |
| | | 637 | | |
| | 0 | 638 | | XmlName xmlName = new XmlName(member.Name); |
| | 0 | 639 | | MessagePartDescription part = new MessagePartDescription(xmlName.EncodedName, string.Empty); |
| | 0 | 640 | | part.AdditionalAttributesProvider = part.MemberInfo = member; |
| | 0 | 641 | | part.Index = part.SerializationPosition = partList.Count; |
| | 0 | 642 | | part.Type = (member is PropertyInfo) ? ((PropertyInfo)member).PropertyType : ((FieldInfo)member) |
| | 0 | 643 | | partList.Add(part); |
| | | 644 | | } |
| | 0 | 645 | | return partList; |
| | | 646 | | } |
| | | 647 | | |
| | | 648 | | private XmlMembersMapping LoadHeadersMapping(MessageDescription message, string mappingKey) |
| | | 649 | | { |
| | 130 | 650 | | int headerCount = message.Headers.Count; |
| | | 651 | | |
| | 130 | 652 | | if (headerCount == 0) |
| | | 653 | | { |
| | 128 | 654 | | return null; |
| | | 655 | | } |
| | | 656 | | |
| | 2 | 657 | | if (IsEncoded) |
| | | 658 | | { |
| | 0 | 659 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Forma |
| | | 660 | | } |
| | | 661 | | |
| | 4 | 662 | | int unknownHeaderCount = 0, headerIndex = 0; |
| | 2 | 663 | | XmlReflectionMember[] members = new XmlReflectionMember[headerCount]; |
| | 12 | 664 | | for (int i = 0; i < headerCount; i++) |
| | | 665 | | { |
| | 4 | 666 | | MessageHeaderDescription header = message.Headers[i]; |
| | 4 | 667 | | if (!header.IsUnknownHeaderCollection) |
| | | 668 | | { |
| | 4 | 669 | | members[headerIndex++] = XmlSerializerHelper.GetXmlReflectionMember(header, false/*isRpc*/, |
| | | 670 | | } |
| | | 671 | | else |
| | | 672 | | { |
| | 0 | 673 | | unknownHeaderCount++; |
| | | 674 | | } |
| | | 675 | | } |
| | | 676 | | |
| | 2 | 677 | | if (unknownHeaderCount == headerCount) |
| | | 678 | | { |
| | 0 | 679 | | return null; |
| | | 680 | | } |
| | | 681 | | |
| | 2 | 682 | | if (unknownHeaderCount > 0) |
| | | 683 | | { |
| | 0 | 684 | | XmlReflectionMember[] newMembers = new XmlReflectionMember[headerCount - unknownHeaderCount]; |
| | 0 | 685 | | Array.Copy(members, newMembers, newMembers.Length); |
| | 0 | 686 | | members = newMembers; |
| | | 687 | | } |
| | | 688 | | |
| | 2 | 689 | | return ImportMembersMapping(ContractName, ContractNamespace, members, false /*isWrapped*/, false /*i |
| | | 690 | | } |
| | | 691 | | |
| | | 692 | | internal XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] mem |
| | | 693 | | { |
| | 132 | 694 | | string key = mappingKey.StartsWith(":", StringComparison.Ordinal) ? _keyBase + mappingKey : mappingK |
| | 132 | 695 | | return _parent._importer.ImportMembersMapping(new XmlName(elementName, true /*isEncoded*/), ns, memb |
| | | 696 | | } |
| | | 697 | | |
| | | 698 | | internal XmlMembersMapping ImportFaultElement(FaultDescription fault, out XmlQualifiedName elementName) |
| | | 699 | | { |
| | | 700 | | // the number of reflection members is always 1 because there is only one fault detail type |
| | 0 | 701 | | XmlReflectionMember[] members = new XmlReflectionMember[1]; |
| | | 702 | | |
| | 0 | 703 | | XmlName faultElementName = fault.ElementName; |
| | 0 | 704 | | string faultNamespace = fault.Namespace; |
| | 0 | 705 | | if (faultElementName == null) |
| | | 706 | | { |
| | 0 | 707 | | XmlTypeMapping mapping = _parent._importer.ImportTypeMapping(fault.DetailType, IsEncoded); |
| | 0 | 708 | | faultElementName = new XmlName(mapping.ElementName, IsEncoded); |
| | 0 | 709 | | faultNamespace = mapping.Namespace; |
| | 0 | 710 | | if (faultElementName == null) |
| | | 711 | | { |
| | 0 | 712 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.F |
| | | 713 | | } |
| | | 714 | | } |
| | | 715 | | |
| | 0 | 716 | | elementName = new XmlQualifiedName(faultElementName.DecodedName, faultNamespace); |
| | | 717 | | |
| | 0 | 718 | | members[0] = XmlSerializerHelper.GetXmlReflectionMember(null /*memberName*/, faultElementName, fault |
| | 0 | 719 | | null /*additionalAttributesProvider*/, false /*isMultiple*/, IsEncoded, false /*isWrapped*/); |
| | | 720 | | |
| | 0 | 721 | | string mappingKey = "fault:" + faultElementName.DecodedName + ":" + faultNamespace; |
| | 0 | 722 | | return ImportMembersMapping(faultElementName.EncodedName, faultNamespace, members, false /*hasWrappe |
| | | 723 | | } |
| | | 724 | | } |
| | | 725 | | |
| | | 726 | | private class XmlSerializerImporter |
| | | 727 | | { |
| | | 728 | | private readonly string _defaultNs; |
| | | 729 | | private XmlReflectionImporter _xmlImporter; |
| | | 730 | | private SoapReflectionImporter _soapImporter; |
| | | 731 | | private Dictionary<string, XmlMembersMapping> _xmlMappings; |
| | | 732 | | |
| | 34 | 733 | | internal XmlSerializerImporter(string defaultNs) |
| | | 734 | | { |
| | 34 | 735 | | _defaultNs = defaultNs; |
| | 34 | 736 | | _xmlImporter = null; |
| | 34 | 737 | | _soapImporter = null; |
| | 34 | 738 | | } |
| | | 739 | | |
| | | 740 | | private SoapReflectionImporter SoapImporter |
| | | 741 | | { |
| | | 742 | | get |
| | | 743 | | { |
| | 42 | 744 | | if (_soapImporter == null) |
| | | 745 | | { |
| | 6 | 746 | | _soapImporter = new SoapReflectionImporter(NamingHelper.CombineUriStrings(_defaultNs, "encod |
| | | 747 | | } |
| | 42 | 748 | | return _soapImporter; |
| | | 749 | | } |
| | | 750 | | } |
| | | 751 | | |
| | | 752 | | private XmlReflectionImporter XmlImporter |
| | | 753 | | { |
| | | 754 | | get |
| | | 755 | | { |
| | 108 | 756 | | if (_xmlImporter == null) |
| | | 757 | | { |
| | 30 | 758 | | _xmlImporter = new XmlReflectionImporter(_defaultNs); |
| | | 759 | | } |
| | 108 | 760 | | return _xmlImporter; |
| | | 761 | | } |
| | | 762 | | } |
| | | 763 | | |
| | | 764 | | private Dictionary<string, XmlMembersMapping> XmlMappings |
| | | 765 | | { |
| | | 766 | | get |
| | | 767 | | { |
| | 264 | 768 | | if (_xmlMappings == null) |
| | | 769 | | { |
| | 32 | 770 | | _xmlMappings = new Dictionary<string, XmlMembersMapping>(); |
| | | 771 | | } |
| | 264 | 772 | | return _xmlMappings; |
| | | 773 | | } |
| | | 774 | | } |
| | | 775 | | |
| | | 776 | | internal XmlMembersMapping ImportMembersMapping(XmlName elementName, string ns, XmlReflectionMember[] me |
| | | 777 | | { |
| | 132 | 778 | | string mappingName = elementName.DecodedName; |
| | 132 | 779 | | if (XmlMappings.TryGetValue(mappingKey, out XmlMembersMapping mapping)) |
| | | 780 | | { |
| | 0 | 781 | | return mapping; |
| | | 782 | | } |
| | | 783 | | |
| | 132 | 784 | | if (isEncoded) |
| | | 785 | | { |
| | 32 | 786 | | mapping = SoapImporter.ImportMembersMapping(mappingName, ns, members, hasWrapperElement, rpc); |
| | | 787 | | } |
| | | 788 | | else |
| | | 789 | | { |
| | 100 | 790 | | mapping = XmlImporter.ImportMembersMapping(mappingName, ns, members, hasWrapperElement, rpc); |
| | | 791 | | } |
| | | 792 | | |
| | 132 | 793 | | mapping.SetKey(mappingKey); |
| | 132 | 794 | | XmlMappings.Add(mappingKey, mapping); |
| | 132 | 795 | | return mapping; |
| | | 796 | | } |
| | | 797 | | |
| | | 798 | | internal XmlTypeMapping ImportTypeMapping(Type type, bool isEncoded) |
| | | 799 | | { |
| | 0 | 800 | | if (isEncoded) |
| | | 801 | | { |
| | 0 | 802 | | return SoapImporter.ImportTypeMapping(type); |
| | | 803 | | } |
| | | 804 | | else |
| | | 805 | | { |
| | 0 | 806 | | return XmlImporter.ImportTypeMapping(type); |
| | | 807 | | } |
| | | 808 | | } |
| | | 809 | | |
| | | 810 | | internal void IncludeType(Type knownType, bool isEncoded) |
| | | 811 | | { |
| | 18 | 812 | | if (isEncoded) |
| | | 813 | | { |
| | 10 | 814 | | SoapImporter.IncludeType(knownType); |
| | | 815 | | } |
| | | 816 | | else |
| | | 817 | | { |
| | 8 | 818 | | XmlImporter.IncludeType(knownType); |
| | | 819 | | } |
| | 8 | 820 | | } |
| | | 821 | | } |
| | | 822 | | |
| | | 823 | | internal class SerializerGenerationContext |
| | | 824 | | { |
| | 34 | 825 | | private readonly List<XmlMembersMapping> _mappings = new List<XmlMembersMapping>(); |
| | | 826 | | private XmlSerializer[] _serializers = null; |
| | | 827 | | private readonly Type _type; |
| | 34 | 828 | | private readonly object _thisLock = new object(); |
| | | 829 | | |
| | 34 | 830 | | internal SerializerGenerationContext(Type type) |
| | | 831 | | { |
| | 34 | 832 | | _type = type; |
| | 34 | 833 | | } |
| | | 834 | | |
| | | 835 | | // returns a stub to a serializer |
| | | 836 | | internal SerializerStub AddSerializer(XmlMembersMapping mapping) |
| | | 837 | | { |
| | 260 | 838 | | int handle = -1; |
| | 260 | 839 | | if (mapping != null) |
| | | 840 | | { |
| | 132 | 841 | | handle = ((IList)_mappings).Add(mapping); |
| | | 842 | | } |
| | | 843 | | |
| | 260 | 844 | | return new SerializerStub(this, mapping, handle); |
| | | 845 | | } |
| | | 846 | | |
| | | 847 | | internal XmlSerializer GetSerializer(int handle) |
| | | 848 | | { |
| | 82 | 849 | | if (handle < 0) |
| | | 850 | | { |
| | 40 | 851 | | return null; |
| | | 852 | | } |
| | | 853 | | |
| | 42 | 854 | | if (_serializers == null) |
| | | 855 | | { |
| | 20 | 856 | | lock (_thisLock) |
| | | 857 | | { |
| | 20 | 858 | | if (_serializers == null) |
| | | 859 | | { |
| | 20 | 860 | | _serializers = GenerateSerializers(); |
| | | 861 | | } |
| | 20 | 862 | | } |
| | | 863 | | } |
| | 42 | 864 | | return _serializers[handle]; |
| | | 865 | | } |
| | | 866 | | |
| | | 867 | | private XmlSerializer[] GenerateSerializers() |
| | | 868 | | { |
| | | 869 | | //this.Mappings may have duplicate mappings (for e.g. same message contract is used by more than one |
| | | 870 | | //XmlSerializer.FromMappings require unique mappings. The following code uniquifies, calls FromMappi |
| | 20 | 871 | | List<XmlMembersMapping> uniqueMappings = new List<XmlMembersMapping>(); |
| | 20 | 872 | | int[] uniqueIndexes = new int[_mappings.Count]; |
| | 176 | 873 | | for (int srcIndex = 0; srcIndex < _mappings.Count; srcIndex++) |
| | | 874 | | { |
| | 68 | 875 | | XmlMembersMapping mapping = _mappings[srcIndex]; |
| | 68 | 876 | | int uniqueIndex = uniqueMappings.IndexOf(mapping); |
| | 68 | 877 | | if (uniqueIndex < 0) |
| | | 878 | | { |
| | 68 | 879 | | uniqueMappings.Add(mapping); |
| | 68 | 880 | | uniqueIndex = uniqueMappings.Count - 1; |
| | | 881 | | } |
| | 68 | 882 | | uniqueIndexes[srcIndex] = uniqueIndex; |
| | | 883 | | } |
| | 20 | 884 | | XmlSerializer[] uniqueSerializers = CreateSerializersFromMappings(uniqueMappings.ToArray(), _type); |
| | 20 | 885 | | if (uniqueMappings.Count == _mappings.Count) |
| | | 886 | | { |
| | 20 | 887 | | return uniqueSerializers; |
| | | 888 | | } |
| | | 889 | | |
| | 0 | 890 | | XmlSerializer[] serializers = new XmlSerializer[_mappings.Count]; |
| | 0 | 891 | | for (int i = 0; i < _mappings.Count; i++) |
| | | 892 | | { |
| | 0 | 893 | | serializers[i] = uniqueSerializers[uniqueIndexes[i]]; |
| | | 894 | | } |
| | 0 | 895 | | return serializers; |
| | | 896 | | } |
| | | 897 | | |
| | | 898 | | private XmlSerializer[] CreateSerializersFromMappings(XmlMapping[] mappings, Type type) |
| | | 899 | | { |
| | 20 | 900 | | return XmlSerializer.FromMappings(mappings, type); |
| | | 901 | | } |
| | | 902 | | } |
| | | 903 | | |
| | | 904 | | internal struct SerializerStub |
| | | 905 | | { |
| | | 906 | | private readonly SerializerGenerationContext _context; |
| | | 907 | | |
| | | 908 | | internal readonly XmlMembersMapping Mapping; |
| | | 909 | | internal readonly int Handle; |
| | | 910 | | |
| | | 911 | | internal SerializerStub(SerializerGenerationContext context, XmlMembersMapping mapping, int handle) |
| | | 912 | | { |
| | 260 | 913 | | _context = context; |
| | 260 | 914 | | Mapping = mapping; |
| | 260 | 915 | | Handle = handle; |
| | 260 | 916 | | } |
| | | 917 | | |
| | | 918 | | internal XmlSerializer GetSerializer() |
| | | 919 | | { |
| | 82 | 920 | | return _context.GetSerializer(Handle); |
| | | 921 | | } |
| | | 922 | | } |
| | | 923 | | |
| | | 924 | | internal class XmlSerializerFaultContractInfo |
| | | 925 | | { |
| | | 926 | | private readonly SerializerStub _serializerStub; |
| | | 927 | | private XmlSerializerObjectSerializer _serializer; |
| | | 928 | | |
| | 0 | 929 | | internal XmlSerializerFaultContractInfo(FaultContractInfo faultContractInfo, SerializerStub serializerSt |
| | 0 | 930 | | XmlQualifiedName faultContractElementName) |
| | | 931 | | { |
| | 0 | 932 | | FaultContractInfo = faultContractInfo ?? throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumen |
| | 0 | 933 | | _serializerStub = serializerStub; |
| | 0 | 934 | | FaultContractElementName = faultContractElementName ?? throw DiagnosticUtility.ExceptionUtility.Thro |
| | 0 | 935 | | } |
| | | 936 | | |
| | 0 | 937 | | internal FaultContractInfo FaultContractInfo { get; } |
| | | 938 | | |
| | 0 | 939 | | internal XmlQualifiedName FaultContractElementName { get; } |
| | | 940 | | |
| | | 941 | | internal XmlSerializerObjectSerializer Serializer |
| | | 942 | | { |
| | | 943 | | get |
| | | 944 | | { |
| | 0 | 945 | | if (_serializer == null) |
| | | 946 | | { |
| | 0 | 947 | | _serializer = new XmlSerializerObjectSerializer(FaultContractInfo.Detail, FaultContractEleme |
| | | 948 | | } |
| | | 949 | | |
| | 0 | 950 | | return _serializer; |
| | | 951 | | } |
| | | 952 | | } |
| | | 953 | | } |
| | | 954 | | |
| | | 955 | | internal class MessageInfo : XmlSerializerOperationFormatter.MessageInfo |
| | | 956 | | { |
| | | 957 | | private SerializerStub _headers; |
| | | 958 | | private SerializerStub _body; |
| | | 959 | | private OperationFormatter.MessageHeaderDescriptionTable _headerDescriptionTable; |
| | | 960 | | private MessageHeaderDescription _unknownHeaderDescription; |
| | | 961 | | private MessagePartDescriptionCollection _rpcEncodedTypedMessageBodyParts; |
| | | 962 | | |
| | | 963 | | internal XmlMembersMapping BodyMapping |
| | | 964 | | { |
| | 70 | 965 | | get { return _body.Mapping; } |
| | | 966 | | } |
| | | 967 | | |
| | | 968 | | internal override XmlSerializer BodySerializer |
| | | 969 | | { |
| | 40 | 970 | | get { return _body.GetSerializer(); } |
| | | 971 | | } |
| | | 972 | | |
| | | 973 | | internal XmlMembersMapping HeadersMapping |
| | | 974 | | { |
| | 0 | 975 | | get { return _headers.Mapping; } |
| | | 976 | | } |
| | | 977 | | |
| | | 978 | | internal override XmlSerializer HeaderSerializer |
| | | 979 | | { |
| | 42 | 980 | | get { return _headers.GetSerializer(); } |
| | | 981 | | } |
| | | 982 | | |
| | | 983 | | internal override OperationFormatter.MessageHeaderDescriptionTable HeaderDescriptionTable |
| | | 984 | | { |
| | 42 | 985 | | get { return _headerDescriptionTable; } |
| | | 986 | | } |
| | | 987 | | |
| | | 988 | | internal override MessageHeaderDescription UnknownHeaderDescription |
| | | 989 | | { |
| | 42 | 990 | | get { return _unknownHeaderDescription; } |
| | | 991 | | } |
| | | 992 | | |
| | | 993 | | internal override MessagePartDescriptionCollection RpcEncodedTypedMessageBodyParts |
| | | 994 | | { |
| | 40 | 995 | | get { return _rpcEncodedTypedMessageBodyParts; } |
| | | 996 | | } |
| | | 997 | | |
| | | 998 | | internal void SetBody(SerializerStub body, MessagePartDescriptionCollection rpcEncodedTypedMessageBodyPa |
| | | 999 | | { |
| | 130 | 1000 | | _body = body; |
| | 130 | 1001 | | _rpcEncodedTypedMessageBodyParts = rpcEncodedTypedMessageBodyParts; |
| | 130 | 1002 | | } |
| | | 1003 | | |
| | | 1004 | | internal void SetHeaders(SerializerStub headers) |
| | | 1005 | | { |
| | 130 | 1006 | | _headers = headers; |
| | 130 | 1007 | | } |
| | | 1008 | | |
| | | 1009 | | internal void SetHeaderDescriptionTable(OperationFormatter.MessageHeaderDescriptionTable headerDescripti |
| | | 1010 | | { |
| | 130 | 1011 | | _headerDescriptionTable = headerDescriptionTable; |
| | 130 | 1012 | | } |
| | | 1013 | | |
| | | 1014 | | internal void SetUnknownHeaderDescription(MessageHeaderDescription unknownHeaderDescription) |
| | | 1015 | | { |
| | 0 | 1016 | | _unknownHeaderDescription = unknownHeaderDescription; |
| | 0 | 1017 | | } |
| | | 1018 | | } |
| | | 1019 | | } |
| | | 1020 | | } |
| | | 1021 | | |
| | | 1022 | | internal static class XmlSerializerHelper |
| | | 1023 | | { |
| | | 1024 | | internal static XmlReflectionMember GetXmlReflectionMember(MessagePartDescription part, bool isRpc, bool isEncod |
| | | 1025 | | { |
| | | 1026 | | string ns = isRpc ? null : part.Namespace; |
| | | 1027 | | ICustomAttributeProvider additionalAttributesProvider = null; |
| | | 1028 | | if (isEncoded || part.AdditionalAttributesProvider is MemberInfo) |
| | | 1029 | | additionalAttributesProvider = part.AdditionalAttributesProvider; |
| | | 1030 | | |
| | | 1031 | | XmlName memberName = string.IsNullOrEmpty(part.UniquePartName) ? null : new XmlName(part.UniquePartName, tru |
| | | 1032 | | XmlName elementName = part.XmlName; |
| | | 1033 | | return GetXmlReflectionMember(memberName, elementName, ns, part.Type, additionalAttributesProvider, part.Mul |
| | | 1034 | | } |
| | | 1035 | | |
| | | 1036 | | internal static XmlReflectionMember GetXmlReflectionMember(XmlName memberName, XmlName elementName, string ns, T |
| | | 1037 | | { |
| | | 1038 | | if (isEncoded && isMultiple) |
| | | 1039 | | { |
| | | 1040 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFx |
| | | 1041 | | } |
| | | 1042 | | |
| | | 1043 | | XmlReflectionMember member = new XmlReflectionMember |
| | | 1044 | | { |
| | | 1045 | | MemberName = (memberName ?? elementName).DecodedName, |
| | | 1046 | | MemberType = type |
| | | 1047 | | }; |
| | | 1048 | | if (member.MemberType.IsByRef) |
| | | 1049 | | { |
| | | 1050 | | member.MemberType = member.MemberType.GetElementType(); |
| | | 1051 | | } |
| | | 1052 | | |
| | | 1053 | | if (isMultiple) |
| | | 1054 | | { |
| | | 1055 | | member.MemberType = member.MemberType.MakeArrayType(); |
| | | 1056 | | } |
| | | 1057 | | |
| | | 1058 | | if (additionalAttributesProvider != null) |
| | | 1059 | | { |
| | | 1060 | | if (isEncoded) |
| | | 1061 | | { |
| | | 1062 | | member.SoapAttributes = new SoapAttributes(additionalAttributesProvider); |
| | | 1063 | | } |
| | | 1064 | | else |
| | | 1065 | | { |
| | | 1066 | | member.XmlAttributes = new XmlAttributes(additionalAttributesProvider); |
| | | 1067 | | } |
| | | 1068 | | } |
| | | 1069 | | |
| | | 1070 | | if (isEncoded) |
| | | 1071 | | { |
| | | 1072 | | if (member.SoapAttributes is null) |
| | | 1073 | | { |
| | | 1074 | | member.SoapAttributes = new SoapAttributes(); |
| | | 1075 | | } |
| | | 1076 | | else |
| | | 1077 | | { |
| | | 1078 | | Type invalidAttributeType = null; |
| | | 1079 | | if (member.SoapAttributes.SoapAttribute != null) |
| | | 1080 | | { |
| | | 1081 | | invalidAttributeType = typeof(SoapAttributeAttribute); |
| | | 1082 | | } |
| | | 1083 | | else if (member.SoapAttributes.SoapIgnore) |
| | | 1084 | | { |
| | | 1085 | | invalidAttributeType = typeof(SoapIgnoreAttribute); |
| | | 1086 | | } |
| | | 1087 | | else if (member.SoapAttributes.SoapType != null) |
| | | 1088 | | { |
| | | 1089 | | invalidAttributeType = typeof(SoapTypeAttribute); |
| | | 1090 | | } |
| | | 1091 | | |
| | | 1092 | | if (invalidAttributeType != null) |
| | | 1093 | | { |
| | | 1094 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Forma |
| | | 1095 | | } |
| | | 1096 | | } |
| | | 1097 | | |
| | | 1098 | | if (member.SoapAttributes.SoapElement == null) |
| | | 1099 | | { |
| | | 1100 | | member.SoapAttributes.SoapElement = new SoapElementAttribute(elementName.DecodedName); |
| | | 1101 | | } |
| | | 1102 | | } |
| | | 1103 | | else |
| | | 1104 | | { |
| | | 1105 | | if (member.XmlAttributes is null) |
| | | 1106 | | { |
| | | 1107 | | member.XmlAttributes = new XmlAttributes(); |
| | | 1108 | | } |
| | | 1109 | | else |
| | | 1110 | | { |
| | | 1111 | | Type invalidAttributeType = null; |
| | | 1112 | | if (member.XmlAttributes.XmlAttribute != null) |
| | | 1113 | | { |
| | | 1114 | | invalidAttributeType = typeof(XmlAttributeAttribute); |
| | | 1115 | | } |
| | | 1116 | | else if (member.XmlAttributes.XmlAnyAttribute != null && !isWrapped) |
| | | 1117 | | { |
| | | 1118 | | invalidAttributeType = typeof(XmlAnyAttributeAttribute); |
| | | 1119 | | } |
| | | 1120 | | else if (member.XmlAttributes.XmlChoiceIdentifier != null) |
| | | 1121 | | { |
| | | 1122 | | invalidAttributeType = typeof(XmlChoiceIdentifierAttribute); |
| | | 1123 | | } |
| | | 1124 | | else if (member.XmlAttributes.XmlIgnore) |
| | | 1125 | | { |
| | | 1126 | | invalidAttributeType = typeof(XmlIgnoreAttribute); |
| | | 1127 | | } |
| | | 1128 | | else if (member.XmlAttributes.Xmlns) |
| | | 1129 | | { |
| | | 1130 | | invalidAttributeType = typeof(XmlNamespaceDeclarationsAttribute); |
| | | 1131 | | } |
| | | 1132 | | else if (member.XmlAttributes.XmlText != null) |
| | | 1133 | | { |
| | | 1134 | | invalidAttributeType = typeof(XmlTextAttribute); |
| | | 1135 | | } |
| | | 1136 | | else if (member.XmlAttributes.XmlEnum != null) |
| | | 1137 | | { |
| | | 1138 | | invalidAttributeType = typeof(XmlEnumAttribute); |
| | | 1139 | | } |
| | | 1140 | | |
| | | 1141 | | if (invalidAttributeType != null) |
| | | 1142 | | { |
| | | 1143 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Forma |
| | | 1144 | | } |
| | | 1145 | | |
| | | 1146 | | if (member.XmlAttributes.XmlArray != null && isMultiple) |
| | | 1147 | | { |
| | | 1148 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Forma |
| | | 1149 | | } |
| | | 1150 | | } |
| | | 1151 | | |
| | | 1152 | | bool isArray = member.MemberType.IsArray; |
| | | 1153 | | if ((isArray && !isMultiple && member.MemberType != typeof(byte[])) || |
| | | 1154 | | (!isArray && typeof(IEnumerable).IsAssignableFrom(member.MemberType) && member.MemberType != typeof(s |
| | | 1155 | | { |
| | | 1156 | | if (member.XmlAttributes.XmlArray != null) |
| | | 1157 | | { |
| | | 1158 | | if (member.XmlAttributes.XmlArray.ElementName == string.Empty) |
| | | 1159 | | { |
| | | 1160 | | member.XmlAttributes.XmlArray.ElementName = elementName.DecodedName; |
| | | 1161 | | } |
| | | 1162 | | |
| | | 1163 | | if (member.XmlAttributes.XmlArray.Namespace == null) |
| | | 1164 | | { |
| | | 1165 | | member.XmlAttributes.XmlArray.Namespace = ns; |
| | | 1166 | | } |
| | | 1167 | | } |
| | | 1168 | | else if (HasNoXmlParameterAttributes(member.XmlAttributes)) |
| | | 1169 | | { |
| | | 1170 | | member.XmlAttributes.XmlArray = new XmlArrayAttribute |
| | | 1171 | | { |
| | | 1172 | | ElementName = elementName.DecodedName, |
| | | 1173 | | Namespace = ns |
| | | 1174 | | }; |
| | | 1175 | | } |
| | | 1176 | | } |
| | | 1177 | | else |
| | | 1178 | | { |
| | | 1179 | | if (member.XmlAttributes.XmlElements == null || member.XmlAttributes.XmlElements.Count == 0) |
| | | 1180 | | { |
| | | 1181 | | if (HasNoXmlParameterAttributes(member.XmlAttributes)) |
| | | 1182 | | { |
| | | 1183 | | XmlElementAttribute elementAttribute = new XmlElementAttribute |
| | | 1184 | | { |
| | | 1185 | | ElementName = elementName.DecodedName, |
| | | 1186 | | Namespace = ns |
| | | 1187 | | }; |
| | | 1188 | | member.XmlAttributes.XmlElements.Add(elementAttribute); |
| | | 1189 | | } |
| | | 1190 | | } |
| | | 1191 | | else |
| | | 1192 | | { |
| | | 1193 | | foreach (XmlElementAttribute elementAttribute in member.XmlAttributes.XmlElements) |
| | | 1194 | | { |
| | | 1195 | | if (elementAttribute.ElementName == string.Empty) |
| | | 1196 | | { |
| | | 1197 | | elementAttribute.ElementName = elementName.DecodedName; |
| | | 1198 | | } |
| | | 1199 | | |
| | | 1200 | | if (elementAttribute.Namespace == null) |
| | | 1201 | | { |
| | | 1202 | | elementAttribute.Namespace = ns; |
| | | 1203 | | } |
| | | 1204 | | } |
| | | 1205 | | } |
| | | 1206 | | } |
| | | 1207 | | } |
| | | 1208 | | |
| | | 1209 | | return member; |
| | | 1210 | | } |
| | | 1211 | | |
| | | 1212 | | private static bool HasNoXmlParameterAttributes(XmlAttributes xmlAttributes) |
| | | 1213 | | { |
| | | 1214 | | return xmlAttributes.XmlAnyAttribute == null && |
| | | 1215 | | (xmlAttributes.XmlAnyElements == null || xmlAttributes.XmlAnyElements.Count == 0) && |
| | | 1216 | | xmlAttributes.XmlArray == null && |
| | | 1217 | | xmlAttributes.XmlAttribute == null && |
| | | 1218 | | !xmlAttributes.XmlIgnore && |
| | | 1219 | | xmlAttributes.XmlText == null && |
| | | 1220 | | xmlAttributes.XmlChoiceIdentifier == null && |
| | | 1221 | | (xmlAttributes.XmlElements == null || xmlAttributes.XmlElements.Count == 0) && |
| | | 1222 | | !xmlAttributes.Xmlns; |
| | | 1223 | | } |
| | | 1224 | | } |
| | | 1225 | | } |