< Summary - CoreWCF Coverage — PR #1766

Information
Class: CoreWCF.Dispatcher.DataContractSerializerOperationFormatter
Assembly: CoreWCF.Primitives
File(s): /home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Dispatcher/DataContractSerializerOperationFormatter.cs
Line coverage
70%
Covered lines: 202
Uncovered lines: 83
Coverable lines: 285
Total lines: 674
Line coverage: 70.8%
Branch coverage
61%
Covered branches: 108
Total branches: 176
Branch coverage: 61.3%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
.cctor()100%11100%
.ctor(...)75%121286.66%
CreateMessageInfo(...)85.71%141495.83%
ValidateDataContractType(...)100%22100%
CreatePartInfo(...)50%44100%
AddHeadersToMessage(...)64.28%141475%
AddMessageHeaderForParameter(...)25%4450%
SerializeBody(...)75%121280%
SerializeParameters(...)100%22100%
SerializeParameter(...)33.33%6650%
SerializeParameterPart(...)100%11100%
GetHeadersFromMessage(...)39.47%383854.16%
DeserializeHeaderContents(...)50%4483.33%
DeserializeBody(...)60%202059.25%
DeserializeParameters(...)75%8883.33%
DeserializeParameter(...)25%4433.33%
DeserializeParameterPart(...)100%1115.78%
GetSubstituteDataContractType(...)66.66%6655.55%
.ctor(...)100%22100%
OnWriteStartHeader(...)50%44100%
.ctor(...)100%11100%
WriteObject(...)50%2266.66%
IsStartObject(...)100%22100%
ReadObject(...)100%22100%
ReadObject(...)100%11100%
AsQueryableIfNeeded(...)50%4466.66%

File(s)

/home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Dispatcher/DataContractSerializerOperationFormatter.cs

#LineLine coverage
 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
 4using System;
 5using System.Collections;
 6using System.Collections.Generic;
 7using System.Linq;
 8using System.Reflection;
 9using System.Runtime.Serialization;
 10using System.Xml;
 11using CoreWCF.Channels;
 12using CoreWCF.Description;
 13using CoreWCF.Runtime.Serialization;
 14
 15namespace CoreWCF.Dispatcher
 16{
 17    internal static class DataContractSerializerDefaults
 18    {
 19        internal const bool IgnoreExtensionDataObject = false;
 20        internal const int MaxItemsInObjectGraph = int.MaxValue;
 21
 22        internal static DataContractSerializer CreateSerializer(Type type, int maxItems)
 23        {
 24            return CreateSerializer(type, null, maxItems);
 25        }
 26
 27        internal static DataContractSerializer CreateSerializer(Type type, IList<Type> knownTypes, int maxItems)
 28        {
 29            return new DataContractSerializer(
 30                type,
 31                knownTypes);
 32        }
 33
 34        internal static DataContractSerializer CreateSerializer(Type type, string rootName, string rootNs, int maxItems)
 35        {
 36            return CreateSerializer(type, null, rootName, rootNs, maxItems);
 37        }
 38
 39        internal static DataContractSerializer CreateSerializer(Type type, IList<Type> knownTypes, string rootName, stri
 40        {
 41            XmlDictionary dictionary = new XmlDictionary(2);
 42            return new DataContractSerializer(
 43                type,
 44                dictionary.Add(rootName),
 45                dictionary.Add(rootNs),
 46                knownTypes);
 47        }
 48
 49        internal static DataContractSerializer CreateSerializer(Type type, XmlDictionaryString rootName, XmlDictionarySt
 50        {
 51            return CreateSerializer(type, null, rootName, rootNs, maxItems);
 52        }
 53
 54        internal static DataContractSerializer CreateSerializer(Type type, IList<Type> knownTypes, XmlDictionaryString r
 55        {
 56            return new DataContractSerializer(
 57                type,
 58                rootName,
 59                rootNs,
 60                knownTypes);
 61        }
 62    }
 63
 64    public class DataContractSerializerOperationFormatter : OperationFormatter
 65    {
 466        private static readonly Type s_typeOfIQueryable = typeof(IQueryable);
 467        private static readonly Type s_typeOfIQueryableGeneric = typeof(IQueryable<>);
 468        private static readonly Type s_typeOfIEnumerable = typeof(IEnumerable);
 469        private static readonly Type s_typeOfIEnumerableGeneric = typeof(IEnumerable<>);
 70
 71        protected MessageInfo requestMessageInfo;
 72        protected MessageInfo replyMessageInfo;
 73        private readonly IList<Type> _knownTypes;
 74
 75        private IXsdDataContractExporter _dataContractExporter;
 76        private readonly DataContractSerializerOperationBehavior _serializerFactory;
 77
 78        public DataContractSerializerOperationFormatter(OperationDescription description, DataContractFormatAttribute da
 79            DataContractSerializerOperationBehavior serializerFactory)
 81780            : base(description, dataContractFormatAttribute.Style == OperationFormatStyle.Rpc, false/*isEncoded*/)
 81        {
 81782            if (description == null)
 83            {
 084                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(description));
 85            }
 86
 81787            _serializerFactory = serializerFactory ?? new DataContractSerializerOperationBehavior(description);
 181688            foreach (Type type in description.KnownTypes)
 89            {
 9190                if (_knownTypes == null)
 91                {
 8892                    _knownTypes = new List<Type>();
 93                }
 94
 9195                if (type == null)
 96                {
 097                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR
 98                }
 99
 91100                ValidateDataContractType(type);
 91101                _knownTypes.Add(type);
 102            }
 817103            requestMessageInfo = CreateMessageInfo(dataContractFormatAttribute, RequestDescription, _serializerFactory);
 817104            if (ReplyDescription != null)
 105            {
 813106                replyMessageInfo = CreateMessageInfo(dataContractFormatAttribute, ReplyDescription, _serializerFactory);
 107            }
 817108        }
 109
 110        private MessageInfo CreateMessageInfo(DataContractFormatAttribute dataContractFormatAttribute,
 111            MessageDescription messageDescription, DataContractSerializerOperationBehavior serializerFactory)
 112        {
 1630113            if (messageDescription.IsUntypedMessage)
 114            {
 16115                return null;
 116            }
 117
 1614118            MessageInfo messageInfo = new MessageInfo();
 119
 1614120            MessageBodyDescription body = messageDescription.Body;
 1614121            if (body.WrapperName != null)
 122            {
 1598123                messageInfo.WrapperName = AddToDictionary(body.WrapperName);
 1598124                messageInfo.WrapperNamespace = AddToDictionary(body.WrapperNamespace);
 125            }
 1614126            MessagePartDescriptionCollection parts = body.Parts;
 1614127            messageInfo.BodyParts = new PartInfo[parts.Count];
 5516128            for (int i = 0; i < parts.Count; i++)
 129            {
 1144130                messageInfo.BodyParts[i] = CreatePartInfo(parts[i], dataContractFormatAttribute.Style, serializerFactory
 131            }
 132
 1614133            if (IsValidReturnValue(messageDescription.Body.ReturnValue))
 134            {
 548135                messageInfo.ReturnPart = CreatePartInfo(messageDescription.Body.ReturnValue, dataContractFormatAttribute
 136            }
 137
 1614138            messageInfo.HeaderDescriptionTable = new MessageHeaderDescriptionTable();
 1614139            messageInfo.HeaderParts = new PartInfo[messageDescription.Headers.Count];
 3600140            for (int i = 0; i < messageDescription.Headers.Count; i++)
 141            {
 186142                MessageHeaderDescription headerDescription = messageDescription.Headers[i];
 186143                if (headerDescription.IsUnknownHeaderCollection)
 144                {
 0145                    messageInfo.UnknownHeaderDescription = headerDescription;
 146                }
 147                else
 148                {
 186149                    ValidateDataContractType(headerDescription.Type);
 186150                    messageInfo.HeaderDescriptionTable.Add(headerDescription.Name, headerDescription.Namespace, headerDe
 151                }
 186152                messageInfo.HeaderParts[i] = CreatePartInfo(headerDescription, OperationFormatStyle.Document, serializer
 153            }
 1614154            messageInfo.AnyHeaders = messageInfo.UnknownHeaderDescription != null || messageInfo.HeaderDescriptionTable.
 1614155            return messageInfo;
 156        }
 157
 158        private void ValidateDataContractType(Type type)
 159        {
 2155160            if (_dataContractExporter == null)
 161            {
 801162                _dataContractExporter = XsdDataContractExporterFactory.Create();
 163                //if (_serializerFactory != null && _serializerFactory.DataContractSurrogate != null)
 164                //{
 165                //    ExportOptions options = new ExportOptions();
 166                //    options.DataContractSurrogate = serializerFactory.DataContractSurrogate;
 167                //    dataContractExporter.Options = options;
 168                //}
 169            }
 2155170            _dataContractExporter.GetSchemaTypeName(type); //Throws if the type is not a valid data contract
 2155171        }
 172
 173        private PartInfo CreatePartInfo(MessagePartDescription part, OperationFormatStyle style, DataContractSerializerO
 174        {
 1878175            string ns = (style == OperationFormatStyle.Rpc || part.Namespace == null) ? string.Empty : part.Namespace;
 1878176            PartInfo partInfo = new PartInfo(part, AddToDictionary(part.Name), AddToDictionary(ns), _knownTypes, seriali
 1878177            ValidateDataContractType(partInfo.ContractType);
 1878178            return partInfo;
 179        }
 180
 181        protected override void AddHeadersToMessage(Message message, MessageDescription messageDescription, object[] par
 182        {
 146183            MessageInfo messageInfo = isRequest ? requestMessageInfo : replyMessageInfo;
 146184            PartInfo[] headerParts = messageInfo.HeaderParts;
 146185            if (headerParts == null || headerParts.Length == 0)
 186            {
 139187                return;
 188            }
 189
 7190            MessageHeaders headers = message.Headers;
 30191            for (int i = 0; i < headerParts.Length; i++)
 192            {
 8193                PartInfo headerPart = headerParts[i];
 8194                MessageHeaderDescription headerDescription = (MessageHeaderDescription)headerPart.Description;
 8195                object headerValue = parameters[headerDescription.Index];
 196
 8197                if (headerDescription.Multiple)
 198                {
 0199                    if (headerValue != null)
 200                    {
 0201                        bool isXmlElement = headerDescription.Type == typeof(XmlElement);
 0202                        foreach (object headerItemValue in (IEnumerable)headerValue)
 203                        {
 0204                            AddMessageHeaderForParameter(headers, headerPart, message.Version, headerItemValue, isXmlEle
 205                        }
 206                    }
 207                }
 208                else
 209                {
 8210                    AddMessageHeaderForParameter(headers, headerPart, message.Version, headerValue, false/*isXmlElement*
 211                }
 212            }
 7213        }
 214
 215        private void AddMessageHeaderForParameter(MessageHeaders headers, PartInfo headerPart, MessageVersion messageVer
 216        {
 8217            MessageHeaderDescription headerDescription = (MessageHeaderDescription)headerPart.Description;
 8218            object valueToSerialize = GetContentOfMessageHeaderOfT(headerDescription, parameterValue, out bool mustUnder
 219
 8220            if (isXmlElement)
 221            {
 0222                if (valueToSerialize == null)
 223                {
 0224                    return;
 225                }
 226
 0227                XmlElement xmlElement = (XmlElement)valueToSerialize;
 0228                headers.Add(new XmlElementMessageHeader(this, messageVersion, xmlElement.LocalName, xmlElement.Namespace
 0229                return;
 230            }
 8231            headers.Add(new DataContractSerializerMessageHeader(headerPart, valueToSerialize, mustUnderstand, actor, rel
 8232        }
 233
 234        protected override void SerializeBody(XmlDictionaryWriter writer, MessageVersion version, string action, Message
 235        {
 135236            if (writer == null)
 237            {
 0238                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(writer)));
 239            }
 240
 135241            if (parameters == null)
 242            {
 0243                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(parameters)))
 244            }
 245
 246            MessageInfo messageInfo;
 135247            if (isRequest)
 248            {
 0249                messageInfo = requestMessageInfo;
 250            }
 251            else
 252            {
 135253                messageInfo = replyMessageInfo;
 254            }
 255
 135256            if (messageInfo.WrapperName != null)
 257            {
 133258                writer.WriteStartElement(messageInfo.WrapperName, messageInfo.WrapperNamespace);
 259            }
 260
 135261            if (messageInfo.ReturnPart != null)
 262            {
 99263                SerializeParameter(writer, messageInfo.ReturnPart, returnValue);
 264            }
 265
 134266            SerializeParameters(writer, messageInfo.BodyParts, parameters);
 134267            if (messageInfo.WrapperName != null)
 268            {
 132269                writer.WriteEndElement();
 270            }
 134271        }
 272
 273        private void SerializeParameters(XmlDictionaryWriter writer, PartInfo[] parts, object[] parameters)
 274        {
 390275            for (int i = 0; i < parts.Length; i++)
 276            {
 61277                PartInfo part = parts[i];
 61278                object graph = parameters[part.Description.Index];
 61279                SerializeParameter(writer, part, graph);
 280            }
 134281        }
 282
 283        private void SerializeParameter(XmlDictionaryWriter writer, PartInfo part, object graph)
 284        {
 160285            if (part.Description.Multiple)
 286            {
 0287                if (graph != null)
 288                {
 0289                    foreach (object item in (IEnumerable)graph)
 290                    {
 0291                        SerializeParameterPart(writer, part, item);
 292                    }
 293                }
 294            }
 295            else
 296            {
 160297                SerializeParameterPart(writer, part, graph);
 298            }
 159299        }
 300
 301        private void SerializeParameterPart(XmlDictionaryWriter writer, PartInfo part, object graph)
 302        {
 303            try
 304            {
 160305                part.Serializer.WriteObject(writer, graph);
 159306            }
 1307            catch (SerializationException sx)
 308            {
 1309                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
 1310                    SR.Format(SR.SFxInvalidMessageBodyErrorSerializingParameter, part.Description.Namespace, part.Descri
 311            }
 159312        }
 313
 314        protected override void GetHeadersFromMessage(Message message, MessageDescription messageDescription, object[] p
 315        {
 154316            MessageInfo messageInfo = isRequest ? requestMessageInfo : replyMessageInfo;
 154317            if (!messageInfo.AnyHeaders)
 318            {
 146319                return;
 320            }
 321
 8322            MessageHeaders headers = message.Headers;
 8323            KeyValuePair<Type, ArrayList>[] multipleHeaderValues = null;
 8324            ArrayList elementList = null;
 8325            if (messageInfo.UnknownHeaderDescription != null)
 326            {
 0327                elementList = new ArrayList();
 328            }
 329
 72330            for (int i = 0; i < headers.Count; i++)
 331            {
 28332                MessageHeaderInfo header = headers[i];
 28333                MessageHeaderDescription headerDescription = messageInfo.HeaderDescriptionTable.Get(header.Name, header.
 28334                if (headerDescription != null)
 335                {
 8336                    if (header.MustUnderstand)
 337                    {
 0338                        headers.UnderstoodHeaders.Add(header);
 339                    }
 340
 8341                    object item = null;
 8342                    XmlDictionaryReader headerReader = headers.GetReaderAtHeader(i);
 343                    try
 344                    {
 8345                        object dataValue = DeserializeHeaderContents(headerReader, messageDescription, headerDescription
 8346                        if (headerDescription.TypedHeader)
 347                        {
 0348                            item = TypedHeaderManager.Create(headerDescription.Type, dataValue, headers[i].MustUnderstan
 349                        }
 350                        else
 351                        {
 8352                            item = dataValue;
 353                        }
 8354                    }
 355                    finally
 356                    {
 8357                        headerReader.Dispose();
 8358                    }
 359
 8360                    if (headerDescription.Multiple)
 361                    {
 0362                        if (multipleHeaderValues == null)
 363                        {
 0364                            multipleHeaderValues = new KeyValuePair<Type, ArrayList>[parameters.Length];
 365                        }
 366
 0367                        if (multipleHeaderValues[headerDescription.Index].Key == null)
 368                        {
 0369                            multipleHeaderValues[headerDescription.Index] = new KeyValuePair<System.Type, System.Collect
 370                        }
 0371                        multipleHeaderValues[headerDescription.Index].Value.Add(item);
 372                    }
 373                    else
 374                    {
 8375                        parameters[headerDescription.Index] = item;
 376                    }
 377                }
 20378                else if (messageInfo.UnknownHeaderDescription != null)
 379                {
 0380                    MessageHeaderDescription unknownHeaderDescription = messageInfo.UnknownHeaderDescription;
 0381                    XmlDictionaryReader headerReader = headers.GetReaderAtHeader(i);
 382                    try
 383                    {
 0384                        XmlDocument doc = new XmlDocument();
 0385                        object dataValue = doc.ReadNode(headerReader);
 0386                        if (dataValue != null && unknownHeaderDescription.TypedHeader)
 387                        {
 0388                            dataValue = TypedHeaderManager.Create(unknownHeaderDescription.Type, dataValue, headers[i].M
 389                        }
 390
 0391                        elementList.Add(dataValue);
 0392                    }
 393                    finally
 394                    {
 0395                        headerReader.Dispose();
 0396                    }
 397                }
 398            }
 8399            if (multipleHeaderValues != null)
 400            {
 0401                for (int i = 0; i < parameters.Length; i++)
 402                {
 0403                    if (multipleHeaderValues[i].Key != null)
 404                    {
 0405                        parameters[i] = multipleHeaderValues[i].Value.ToArray(multipleHeaderValues[i].Key);
 406                    }
 407                }
 408            }
 8409            if (messageInfo.UnknownHeaderDescription != null)
 410            {
 0411                parameters[messageInfo.UnknownHeaderDescription.Index] = elementList.ToArray(messageInfo.UnknownHeaderDe
 412            }
 8413        }
 414
 415        private object DeserializeHeaderContents(XmlDictionaryReader reader, MessageDescription messageDescription, Mess
 416        {
 8417            Type dataContractType = GetSubstituteDataContractType(headerDescription.Type, out bool isQueryable);
 8418            XmlObjectSerializer serializerLocal = _serializerFactory.CreateSerializer(dataContractType, headerDescriptio
 8419            object val = serializerLocal.ReadObject(reader);
 8420            if (isQueryable && val != null)
 421            {
 0422                return Queryable.AsQueryable((IEnumerable)val);
 423            }
 8424            return val;
 425        }
 426
 427        protected override object DeserializeBody(XmlDictionaryReader reader, MessageVersion version, string action, Mes
 428        {
 137429            if (reader == null)
 430            {
 0431                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(reader)));
 432            }
 433
 137434            if (parameters == null)
 435            {
 0436                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(parameters)))
 437            }
 438
 439            MessageInfo messageInfo;
 137440            if (isRequest)
 441            {
 137442                messageInfo = requestMessageInfo;
 443            }
 444            else
 445            {
 0446                messageInfo = replyMessageInfo;
 447            }
 448
 137449            if (messageInfo.WrapperName != null)
 450            {
 137451                if (!reader.IsStartElement(messageInfo.WrapperName, messageInfo.WrapperNamespace))
 452                {
 0453                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.Format(SR.SF
 454                }
 455
 137456                bool isEmptyElement = reader.IsEmptyElement;
 137457                reader.Read();
 137458                if (isEmptyElement)
 459                {
 21460                    return null;
 461                }
 462            }
 116463            object returnValue = null;
 116464            if (messageInfo.ReturnPart != null)
 465            {
 0466                while (true)
 467                {
 0468                    PartInfo part = messageInfo.ReturnPart;
 0469                    if (part.Serializer.IsStartObject(reader))
 470                    {
 0471                        returnValue = DeserializeParameter(reader, part, isRequest);
 0472                        break;
 473                    }
 0474                    if (!reader.IsStartElement())
 475                    {
 476                        break;
 477                    }
 478
 0479                    TraceAndSkipElement(reader);
 480                }
 481            }
 116482            DeserializeParameters(reader, messageInfo.BodyParts, parameters, isRequest);
 116483            if (messageInfo.WrapperName != null)
 484            {
 116485                reader.ReadEndElement();
 486            }
 487
 116488            return returnValue;
 489        }
 490
 491        private void DeserializeParameters(XmlDictionaryReader reader, PartInfo[] parts, object[] parameters, bool isReq
 492        {
 116493            int nextPartIndex = 0;
 226494            while (reader.IsStartElement())
 495            {
 444496                for (int i = nextPartIndex; i < parts.Length; i++)
 497                {
 112498                    PartInfo part = parts[i];
 112499                    if (part.Serializer.IsStartObject(reader))
 500                    {
 112501                        object parameterValue = DeserializeParameter(reader, part, isRequest);
 112502                        parameters[part.Description.Index] = parameterValue;
 112503                        nextPartIndex = i + 1;
 504                    }
 505                    else
 506                    {
 0507                        parameters[part.Description.Index] = null;
 508                    }
 509                }
 510
 110511                if (reader.IsStartElement())
 512                {
 0513                    TraceAndSkipElement(reader);
 514                }
 515            }
 116516        }
 517
 518        private object DeserializeParameter(XmlDictionaryReader reader, PartInfo part, bool isRequest)
 519        {
 112520            if (part.Description.Multiple)
 521            {
 0522                ArrayList items = new ArrayList();
 0523                while (part.Serializer.IsStartObject(reader))
 524                {
 0525                    items.Add(DeserializeParameterPart(reader, part, isRequest));
 526                }
 527
 0528                return items.ToArray(part.Description.Type);
 529            }
 112530            return DeserializeParameterPart(reader, part, isRequest);
 531        }
 532
 533        private object DeserializeParameterPart(XmlDictionaryReader reader, PartInfo part, bool isRequest)
 534        {
 535            object val;
 536            try
 537            {
 112538                val = part.ReadObject(reader);
 112539            }
 0540            catch (System.InvalidOperationException e)
 541            {
 0542                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
 0543                    SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespace, part.Desc
 544            }
 0545            catch (System.Runtime.Serialization.InvalidDataContractException e)
 546            {
 0547                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(
 0548                    SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespace, part.Desc
 549            }
 0550            catch (System.FormatException e)
 551            {
 0552                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 0553                    NetDispatcherFaultException.CreateDeserializationFailedFault(
 0554                        SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameterMore, part.Description.Namespace, p
 0555                                     e));
 556            }
 0557            catch (System.Runtime.Serialization.SerializationException e)
 558            {
 0559                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 0560                    NetDispatcherFaultException.CreateDeserializationFailedFault(
 0561                        SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameterMore, part.Description.Namespace, p
 0562                                     e));
 563            }
 564
 112565            return val;
 566        }
 567
 568        internal static Type GetSubstituteDataContractType(Type type, out bool isQueryable)
 569        {
 2045570            if (type == s_typeOfIQueryable)
 571            {
 0572                isQueryable = true;
 0573                return s_typeOfIEnumerable;
 574            }
 575
 2045576            if (type.GetTypeInfo().IsGenericType &&
 2045577                type.GetGenericTypeDefinition() == s_typeOfIQueryableGeneric)
 578            {
 0579                isQueryable = true;
 0580                return s_typeOfIEnumerableGeneric.MakeGenericType(type.GetGenericArguments());
 581            }
 582
 2045583            isQueryable = false;
 2045584            return type;
 585        }
 586
 587        private class DataContractSerializerMessageHeader : XmlObjectSerializerHeader
 588        {
 589            private readonly PartInfo _headerPart;
 590
 591            public DataContractSerializerMessageHeader(PartInfo headerPart, object headerValue, bool mustUnderstand, str
 8592                : base(headerPart.DictionaryName.Value, headerPart.DictionaryNamespace.Value, headerValue, headerPart.Se
 593            {
 8594                _headerPart = headerPart;
 8595            }
 596
 597            protected override void OnWriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion)
 598            {
 599                //Prefix needed since there may be xsi:type attribute at toplevel with qname value where ns = ""
 8600                string prefix = (Namespace == null || Namespace.Length == 0) ? string.Empty : "h";
 8601                writer.WriteStartElement(prefix, _headerPart.DictionaryName, _headerPart.DictionaryNamespace);
 8602                WriteHeaderAttributes(writer, messageVersion);
 8603            }
 604        }
 605
 606
 607        protected class MessageInfo
 608        {
 609            internal PartInfo[] HeaderParts;
 610            public XmlDictionaryString WrapperName;
 611            public XmlDictionaryString WrapperNamespace;
 612            public PartInfo[] BodyParts;
 613            public PartInfo ReturnPart;
 614            internal MessageHeaderDescriptionTable HeaderDescriptionTable;
 615            internal MessageHeaderDescription UnknownHeaderDescription;
 616            internal bool AnyHeaders;
 617        }
 618
 619        protected class PartInfo
 620        {
 621            private XmlObjectSerializer _serializer;
 622            private readonly IList<Type> _knownTypes;
 623            private readonly DataContractSerializerOperationBehavior _serializerFactory;
 624            private readonly bool _isQueryable;
 625
 626            public PartInfo(MessagePartDescription description, XmlDictionaryString dictionaryName, XmlDictionaryString 
 627                IList<Type> knownTypes, DataContractSerializerOperationBehavior behavior)
 1880628            {
 1880629                DictionaryName = dictionaryName;
 630                DictionaryNamespace = dictionaryNamespace;
 1880631                Description = description;
 1880632                _knownTypes = knownTypes;
 1880633                _serializerFactory = behavior;
 1880634
 1880635                ContractType = GetSubstituteDataContractType(description.Type, out _isQueryable);
 636            }
 1880637
 1880638            public Type ContractType { get; }
 639
 2131640            public MessagePartDescription Description { get; }
 641
 463642            public XmlDictionaryString DictionaryName { get; }
 643
 269644            public XmlDictionaryString DictionaryNamespace { get; }
 645
 269646            public XmlObjectSerializer Serializer
 647            {
 648                get
 649                {
 650                    if (_serializer == null)
 651                    {
 394652                        _serializer = _serializerFactory.CreateSerializer(ContractType, DictionaryName, DictionaryNamesp
 653                    }
 253654                    return _serializer;
 655                }
 394656            }
 657
 658            public object ReadObject(XmlDictionaryReader reader)
 659            {
 660                return ReadObject(reader, Serializer);
 661            }
 662
 663            public object ReadObject(XmlDictionaryReader reader, XmlObjectSerializer serializer)
 664            {
 665                object val = _serializer.ReadObject(reader, false /* verifyObjectName */);
 666                if (_isQueryable && val != null)
 667                {
 668                    return Queryable.AsQueryable((IEnumerable)val);
 669                }
 670                return val;
 388671            }
 672        }
 244673    }
 244674}
Generated by: ReportGenerator 5.5.11.0
08/09/2026 - 10:15:49
GitHub | reportgenerator.io

Methods/Properties

.cctor()
.ctor(CoreWCF.Description.OperationDescription,CoreWCF.DataContractFormatAttribute,CoreWCF.Description.DataContractSerializerOperationBehavior)
CreateMessageInfo(CoreWCF.DataContractFormatAttribute,CoreWCF.Description.MessageDescription,CoreWCF.Description.DataContractSerializerOperationBehavior)
ValidateDataContractType(System.Type)
CreatePartInfo(CoreWCF.Description.MessagePartDescription,CoreWCF.OperationFormatStyle,CoreWCF.Description.DataContractSerializerOperationBehavior)
AddHeadersToMessage(CoreWCF.Channels.Message,CoreWCF.Description.MessageDescription,System.Object[],System.Boolean)
AddMessageHeaderForParameter(CoreWCF.Channels.MessageHeaders,CoreWCF.Dispatcher.DataContractSerializerOperationFormatter/PartInfo,CoreWCF.Channels.MessageVersion,System.Object,System.Boolean)
SerializeBody(System.Xml.XmlDictionaryWriter,CoreWCF.Channels.MessageVersion,System.String,CoreWCF.Description.MessageDescription,System.Object,System.Object[],System.Boolean)
SerializeParameters(System.Xml.XmlDictionaryWriter,CoreWCF.Dispatcher.DataContractSerializerOperationFormatter/PartInfo[],System.Object[])
SerializeParameter(System.Xml.XmlDictionaryWriter,CoreWCF.Dispatcher.DataContractSerializerOperationFormatter/PartInfo,System.Object)
SerializeParameterPart(System.Xml.XmlDictionaryWriter,CoreWCF.Dispatcher.DataContractSerializerOperationFormatter/PartInfo,System.Object)
GetHeadersFromMessage(CoreWCF.Channels.Message,CoreWCF.Description.MessageDescription,System.Object[],System.Boolean)
DeserializeHeaderContents(System.Xml.XmlDictionaryReader,CoreWCF.Description.MessageDescription,CoreWCF.Description.MessageHeaderDescription)
DeserializeBody(System.Xml.XmlDictionaryReader,CoreWCF.Channels.MessageVersion,System.String,CoreWCF.Description.MessageDescription,System.Object[],System.Boolean)
DeserializeParameters(System.Xml.XmlDictionaryReader,CoreWCF.Dispatcher.DataContractSerializerOperationFormatter/PartInfo[],System.Object[],System.Boolean)
DeserializeParameter(System.Xml.XmlDictionaryReader,CoreWCF.Dispatcher.DataContractSerializerOperationFormatter/PartInfo,System.Boolean)
DeserializeParameterPart(System.Xml.XmlDictionaryReader,CoreWCF.Dispatcher.DataContractSerializerOperationFormatter/PartInfo,System.Boolean)
GetSubstituteDataContractType(System.Type,System.Boolean&)
.ctor(CoreWCF.Dispatcher.DataContractSerializerOperationFormatter/PartInfo,System.Object,System.Boolean,System.String,System.Boolean)
OnWriteStartHeader(System.Xml.XmlDictionaryWriter,CoreWCF.Channels.MessageVersion)
.ctor(CoreWCF.Description.MessagePartDescription,System.Xml.XmlDictionaryString,System.Xml.XmlDictionaryString,System.Collections.Generic.IList`1<System.Type>,CoreWCF.Description.DataContractSerializerOperationBehavior)
ContractType()
Description()
DictionaryName()
DictionaryNamespace()
Serializer()
AotSerializer()
WriteObject(System.Xml.XmlDictionaryWriter,System.Object)
IsStartObject(System.Xml.XmlDictionaryReader)
ReadObject(System.Xml.XmlDictionaryReader)
ReadObject(System.Xml.XmlDictionaryReader,System.Runtime.Serialization.XmlObjectSerializer)
ReadingSerializer()
AsQueryableIfNeeded(System.Object)