< Summary - CoreWCF Coverage — PR #1766

Information
Class: CoreWCF.Dispatcher.DataContractJsonSerializerOperationFormatter
Assembly: CoreWCF.WebHttp
File(s): /home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.WebHttp/src/CoreWCF/Dispatcher/DataContractJsonSerializerOperationFormatter.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 288
Coverable lines: 288
Total lines: 667
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 158
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
.cctor()100%110%
.ctor(...)0%10100%
IsJsonLocalName(...)0%440%
IsStartElement(...)0%220%
IsStartElement(...)0%440%
AddHeadersToMessage(...)0%220%
DeserializeBody(...)0%26260%
GetHeadersFromMessage(...)0%660%
SerializeBody(...)0%16160%
RecreateDataContractJsonSerializer(...)100%110%
DeserializeBareMessageContract(...)0%10100%
DeserializeBodyCore(...)0%880%
DeserializeParameter(...)0%440%
DeserializeParameterPart(...)100%110%
DeserializeParameters(...)0%18180%
SerializeBareMessageContract(...)0%880%
SerializeBody(...)0%12120%
SerializeParameter(...)0%660%
SerializeParameterPart(...)100%110%
SerializeParameters(...)0%220%
ValidateTypeObjectAttribute(...)0%880%
VerifyIsStartElement(...)0%660%
VerifyIsStartElement(...)0%660%
WriteVoidReturn(...)100%110%
TraceAndSkipElement(...)100%110%

File(s)

/home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.WebHttp/src/CoreWCF/Dispatcher/DataContractJsonSerializerOperationFormatter.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.Runtime.Serialization;
 7using System.Runtime.Serialization.Json;
 8using System.Xml;
 9using CoreWCF.Channels;
 10using CoreWCF.Description;
 11
 12namespace CoreWCF.Dispatcher
 13{
 14    internal class DataContractJsonSerializerOperationFormatter : DataContractSerializerOperationFormatter
 15    {
 16        private readonly bool _isBareMessageContractReply;
 17        private readonly bool _isBareMessageContractRequest;
 18        // isWrapped is true when the user has explicitly chosen the response or request format to be Wrapped (allowed o
 19        private readonly bool _isWrapped;
 20
 021        private static readonly DataContractFormatAttribute s_defaultDataContractFormatAttribute = new DataContractForma
 22
 23        public DataContractJsonSerializerOperationFormatter(OperationDescription description, int maxItemsInObjectGraph,
 024            : base(description, s_defaultDataContractFormatAttribute, new DataContractJsonSerializerOperationBehavior(de
 25        {
 026            if (requestMessageInfo != null)
 27            {
 028                if (requestMessageInfo.WrapperName == null)
 29                {
 030                    _isBareMessageContractRequest = true;
 31                }
 32                else
 33                {
 034                    requestMessageInfo.WrapperName = JsonGlobals.RootDictionaryString;
 035                    requestMessageInfo.WrapperNamespace = XmlDictionaryString.Empty;
 36                }
 37            }
 38
 039            if (replyMessageInfo != null)
 40            {
 041                if (replyMessageInfo.WrapperName == null)
 42                {
 043                    _isBareMessageContractReply = true;
 44                }
 45                else
 46                {
 047                    if (useAspNetAjaxJson)
 48                    {
 049                        replyMessageInfo.WrapperName = JsonGlobals.DDictionaryString;
 50                    }
 51                    else
 52                    {
 053                        replyMessageInfo.WrapperName = JsonGlobals.RootDictionaryString;
 54                    }
 055                    replyMessageInfo.WrapperNamespace = XmlDictionaryString.Empty;
 56                }
 57            }
 58
 059            _isWrapped = isWrapped;
 060        }
 61
 62        internal static bool IsJsonLocalName(XmlDictionaryReader reader, string elementName)
 63        {
 064            if (reader.IsStartElement(JsonGlobals.ItemDictionaryString, JsonGlobals.ItemDictionaryString))
 65            {
 066                if (reader.MoveToAttribute(JsonGlobals.ItemString))
 67                {
 068                    return (reader.Value == elementName);
 69                }
 70            }
 71
 072            return false;
 73        }
 74
 75        internal static bool IsStartElement(XmlDictionaryReader reader, string elementName)
 76        {
 077            if (reader.IsStartElement(elementName))
 78            {
 079                return true;
 80            }
 81
 082            return IsJsonLocalName(reader, elementName);
 83        }
 84
 85        internal static bool IsStartElement(XmlDictionaryReader reader, XmlDictionaryString elementName, XmlDictionarySt
 86        {
 087            if (reader.IsStartElement(elementName, elementNamespace))
 88            {
 089                return true;
 90            }
 91
 092            return IsJsonLocalName(reader, (elementName == null) ? null : elementName.Value);
 93        }
 94
 95        protected override void AddHeadersToMessage(Message message, MessageDescription messageDescription, object[] par
 96        {
 097            if (message != null)
 98            {
 099                message.Properties.Add(WebBodyFormatMessageProperty.Name, WebBodyFormatMessageProperty.JsonProperty);
 100            }
 101
 0102            base.AddHeadersToMessage(message, messageDescription, parameters, isRequest);
 0103        }
 104
 105        protected override object DeserializeBody(XmlDictionaryReader reader, MessageVersion version, string action, Mes
 106        {
 0107            if (reader == null)
 108            {
 0109                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(reader)));
 110            }
 111
 0112            if (parameters == null)
 113            {
 0114                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(parameters)))
 115            }
 116
 0117            if (reader.EOF)
 118            {
 0119                return null;
 120            }
 121
 0122            if ((isRequest && _isBareMessageContractRequest) || (!isRequest && _isBareMessageContractReply))
 123            {
 0124                return DeserializeBareMessageContract(reader, parameters, isRequest);
 125            }
 126
 0127            object returnValue = null;
 128
 0129            if (isRequest || _isWrapped)
 130            {
 0131                ValidateTypeObjectAttribute(reader, isRequest);
 0132                returnValue = DeserializeBodyCore(reader, parameters, isRequest);
 133            }
 134            else
 135            {
 0136                if (replyMessageInfo.ReturnPart != null)
 137                {
 0138                    PartInfo part = replyMessageInfo.ReturnPart;
 0139                    DataContractJsonSerializer serializer = part.Serializer as DataContractJsonSerializer;
 140
 0141                    serializer = RecreateDataContractJsonSerializer(serializer, part.ContractType, JsonGlobals.RootStrin
 0142                    VerifyIsStartElement(reader, JsonGlobals.RootString);
 143
 0144                    if (serializer.IsStartObject(reader))
 145                    {
 146                        try
 147                        {
 0148                            returnValue = part.ReadObject(reader, serializer);
 0149                        }
 0150                        catch (InvalidOperationException e)
 151                        {
 0152                            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
 0153                                SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespac
 154                        }
 0155                        catch (InvalidDataContractException e)
 156                        {
 0157                            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(
 0158                                SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespac
 159                        }
 0160                        catch (FormatException e)
 161                        {
 0162                            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 0163                                NetDispatcherFaultException.CreateDeserializationFailedFault(
 0164                                SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameterMore,
 0165                                part.Description.Namespace, part.Description.Name, e.Message),
 0166                                e));
 167                        }
 0168                        catch (SerializationException e)
 169                        {
 0170                            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 0171                                NetDispatcherFaultException.CreateDeserializationFailedFault(
 0172                                SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameterMore,
 0173                                part.Description.Namespace, part.Description.Name, e.Message),
 0174                                e));
 175                        }
 176                    }
 177                }
 0178                else if (replyMessageInfo.BodyParts != null)
 179                {
 0180                    ValidateTypeObjectAttribute(reader, isRequest);
 0181                    returnValue = DeserializeBodyCore(reader, parameters, isRequest);
 182                }
 183
 0184                while (reader.IsStartElement())
 185                {
 0186                    TraceAndSkipElement(reader);
 187                }
 188            }
 189
 0190            return returnValue;
 191        }
 192
 193        protected override void GetHeadersFromMessage(Message message, MessageDescription messageDescription, object[] p
 194        {
 0195            if (message != null)
 196            {
 0197                message.Properties.TryGetValue(WebBodyFormatMessageProperty.Name, out object prop);
 0198                WebBodyFormatMessageProperty formatProperty = (prop as WebBodyFormatMessageProperty);
 0199                if (formatProperty == null)
 200                {
 0201                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR
 202                }
 0203                if (formatProperty.Format != WebContentFormat.Json)
 204                {
 0205                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR
 206                }
 207            }
 208
 0209            base.GetHeadersFromMessage(message, messageDescription, parameters, isRequest);
 0210        }
 211
 212        protected override void SerializeBody(XmlDictionaryWriter writer, MessageVersion version, string action, Message
 213        {
 0214            if ((isRequest && _isBareMessageContractRequest) || (!isRequest && _isBareMessageContractReply))
 215            {
 0216                SerializeBareMessageContract(writer, parameters, isRequest);
 217            }
 218            else
 219            {
 0220                if (isRequest || _isWrapped)
 221                {
 0222                    SerializeBody(writer, returnValue, parameters, isRequest);
 223                }
 224                else
 225                {
 0226                    if (replyMessageInfo.ReturnPart != null)
 227                    {
 0228                        DataContractJsonSerializer serializer = replyMessageInfo.ReturnPart.Serializer as DataContractJs
 0229                        serializer = RecreateDataContractJsonSerializer(serializer, replyMessageInfo.ReturnPart.Contract
 230
 231                        try
 232                        {
 0233                            serializer.WriteObject(writer, returnValue);
 0234                        }
 0235                        catch (SerializationException sx)
 236                        {
 0237                            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
 0238                                SR.Format(SR.SFxInvalidMessageBodyErrorSerializingParameter, replyMessageInfo.ReturnPart
 239                        }
 240                    }
 0241                    else if (replyMessageInfo.BodyParts != null)
 242                    {
 0243                        SerializeBody(writer, returnValue, parameters, isRequest);
 244                    }
 245                }
 246            }
 0247        }
 248
 249        private static DataContractJsonSerializer RecreateDataContractJsonSerializer(DataContractJsonSerializer serializ
 250        {
 0251            DataContractJsonSerializerSettings settings = new DataContractJsonSerializerSettings
 0252            {
 0253                RootName = newRootName,
 0254                KnownTypes = serializer.KnownTypes,
 0255                MaxItemsInObjectGraph = serializer.MaxItemsInObjectGraph,
 0256                IgnoreExtensionDataObject = serializer.IgnoreExtensionDataObject,
 0257                EmitTypeInformation = serializer.EmitTypeInformation,
 0258                DateTimeFormat = serializer.DateTimeFormat,
 0259                UseSimpleDictionaryFormat = serializer.UseSimpleDictionaryFormat
 0260            };
 261
 0262            return new DataContractJsonSerializer(type, settings);
 263        }
 264
 265        private object DeserializeBareMessageContract(XmlDictionaryReader reader, object[] parameters, bool isRequest)
 266        {
 267            MessageInfo messageInfo;
 0268            if (isRequest)
 269            {
 0270                messageInfo = requestMessageInfo;
 271            }
 272            else
 273            {
 0274                messageInfo = replyMessageInfo;
 275            }
 276
 0277            if (messageInfo.BodyParts.Length > 0)
 278            {
 0279                PartInfo part = messageInfo.BodyParts[0];
 0280                DataContractJsonSerializer serializer = part.Serializer as DataContractJsonSerializer;
 0281                serializer = RecreateDataContractJsonSerializer(serializer, part.ContractType, JsonGlobals.RootString);
 282
 0283                while (reader.IsStartElement())
 284                {
 0285                    if (serializer.IsStartObject(reader))
 286                    {
 287                        try
 288                        {
 0289                            parameters[part.Description.Index] = part.ReadObject(reader, serializer);
 0290                            break;
 291                        }
 0292                        catch (InvalidOperationException e)
 293                        {
 0294                            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
 0295                                SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespac
 296                        }
 0297                        catch (InvalidDataContractException e)
 298                        {
 0299                            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(
 0300                                SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespac
 301                        }
 0302                        catch (FormatException e)
 303                        {
 0304                            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 0305                                NetDispatcherFaultException.CreateDeserializationFailedFault(
 0306                                SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameterMore,
 0307                                part.Description.Namespace, part.Description.Name, e.Message),
 0308                                e));
 309                        }
 0310                        catch (SerializationException e)
 311                        {
 0312                            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 0313                                NetDispatcherFaultException.CreateDeserializationFailedFault(
 0314                                SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameterMore,
 0315                                part.Description.Namespace, part.Description.Name, e.Message),
 0316                                e));
 317                        }
 318                    }
 319                    else
 320                    {
 0321                        TraceAndSkipElement(reader);
 322                    }
 323                }
 0324                while (reader.IsStartElement())
 325                {
 0326                    TraceAndSkipElement(reader);
 327                }
 328            }
 329
 0330            return null;
 331        }
 332
 333        private object DeserializeBodyCore(XmlDictionaryReader reader, object[] parameters, bool isRequest)
 334        {
 335            MessageInfo messageInfo;
 0336            if (isRequest)
 337            {
 0338                messageInfo = requestMessageInfo;
 339            }
 340            else
 341            {
 0342                messageInfo = replyMessageInfo;
 343            }
 344
 0345            if (messageInfo.WrapperName != null)
 346            {
 0347                VerifyIsStartElement(reader, messageInfo.WrapperName, messageInfo.WrapperNamespace);
 0348                bool isEmptyElement = reader.IsEmptyElement;
 0349                reader.Read();
 0350                if (isEmptyElement)
 351                {
 0352                    return null;
 353                }
 354            }
 355
 0356            object returnValue = null;
 0357            DeserializeParameters(reader, messageInfo.BodyParts, parameters, messageInfo.ReturnPart, ref returnValue);
 0358            if (messageInfo.WrapperName != null)
 359            {
 0360                reader.ReadEndElement();
 361            }
 362
 0363            return returnValue;
 364        }
 365
 366        private object DeserializeParameter(XmlDictionaryReader reader, PartInfo part)
 367        {
 0368            if (part.Description.Multiple)
 369            {
 0370                ArrayList items = new ArrayList();
 0371                while (part.Serializer.IsStartObject(reader))
 372                {
 0373                    items.Add(DeserializeParameterPart(reader, part));
 374                }
 375
 0376                return items.ToArray(part.Description.Type);
 377            }
 378
 0379            return DeserializeParameterPart(reader, part);
 380        }
 381
 382        private object DeserializeParameterPart(XmlDictionaryReader reader, PartInfo part)
 383        {
 384            object val;
 385            try
 386            {
 0387                val = part.ReadObject(reader);
 0388            }
 0389            catch (InvalidOperationException e)
 390            {
 0391                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
 0392                    SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespace, part.Desc
 393            }
 0394            catch (InvalidDataContractException e)
 395            {
 0396                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(
 0397                    SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespace, part.Desc
 398            }
 0399            catch (FormatException e)
 400            {
 0401                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 0402                    NetDispatcherFaultException.CreateDeserializationFailedFault(
 0403                    SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameterMore,
 0404                    part.Description.Namespace, part.Description.Name, e.Message),
 0405                    e));
 406            }
 0407            catch (SerializationException e)
 408            {
 0409                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 0410                    NetDispatcherFaultException.CreateDeserializationFailedFault(
 0411                    SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameterMore,
 0412                    part.Description.Namespace, part.Description.Name, e.Message),
 0413                    e));
 414            }
 415
 0416            return val;
 417        }
 418
 419        private void DeserializeParameters(XmlDictionaryReader reader, PartInfo[] parts, object[] parameters, PartInfo r
 420        {
 0421            bool[] setParameters = new bool[parameters.Length];
 0422            bool hasReadReturnValue = false;
 0423            int currentIndex = 0;
 424
 0425            while (reader.IsStartElement())
 426            {
 0427                bool hasReadParameter = false;
 428
 0429                for (int i = 0, index = currentIndex; i < parts.Length; i++, index = (index + 1) % parts.Length)
 430                {
 0431                    PartInfo part = parts[index];
 0432                    if (part.Serializer.IsStartObject(reader))
 433                    {
 0434                        currentIndex = i;
 0435                        parameters[part.Description.Index] = DeserializeParameter(reader, part);
 0436                        setParameters[part.Description.Index] = true;
 0437                        hasReadParameter = true;
 438                    }
 439                }
 440
 0441                if (!hasReadParameter)
 442                {
 0443                    if ((returnInfo != null) && !hasReadReturnValue && returnInfo.Serializer.IsStartObject(reader))
 444                    {
 0445                        returnValue = DeserializeParameter(reader, returnInfo);
 0446                        hasReadReturnValue = true;
 447                    }
 448                    else
 449                    {
 0450                        TraceAndSkipElement(reader);
 451                    }
 452                }
 453            }
 454
 0455            for (int i = 0; i < parameters.Length; i++)
 456            {
 0457                if (!setParameters[i])
 458                {
 0459                    parameters[i] = null;
 460                }
 461            }
 0462        }
 463
 464        private void SerializeBareMessageContract(XmlDictionaryWriter writer, object[] parameters, bool isRequest)
 465        {
 0466            if (writer == null)
 467            {
 0468                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(writer)));
 469            }
 470
 0471            if (parameters == null)
 472            {
 0473                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(parameters)))
 474            }
 475
 476            MessageInfo messageInfo;
 0477            if (isRequest)
 478            {
 0479                messageInfo = requestMessageInfo;
 480            }
 481            else
 482            {
 0483                messageInfo = replyMessageInfo;
 484            }
 485
 0486            if (messageInfo.BodyParts.Length > 0)
 487            {
 0488                PartInfo part = messageInfo.BodyParts[0];
 0489                DataContractJsonSerializer serializer = part.Serializer as DataContractJsonSerializer;
 0490                serializer = RecreateDataContractJsonSerializer(serializer, part.ContractType, JsonGlobals.RootString);
 491
 0492                object graph = parameters[part.Description.Index];
 493                try
 494                {
 0495                    serializer.WriteObject(writer, graph);
 0496                }
 0497                catch (SerializationException sx)
 498                {
 0499                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
 0500                        SR.Format(SR.SFxInvalidMessageBodyErrorSerializingParameter, part.Description.Namespace, part.De
 501                }
 502            }
 0503        }
 504
 505        private void SerializeBody(XmlDictionaryWriter writer, object returnValue, object[] parameters, bool isRequest)
 506        {
 0507            if (writer == null)
 508            {
 0509                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(writer)));
 510            }
 511
 0512            if (parameters == null)
 513            {
 0514                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(parameters)))
 515            }
 516
 517            MessageInfo messageInfo;
 0518            if (isRequest)
 519            {
 0520                messageInfo = requestMessageInfo;
 521            }
 522            else
 523            {
 0524                messageInfo = replyMessageInfo;
 525            }
 526
 0527            if (messageInfo.WrapperName != null)
 528            {
 0529                writer.WriteStartElement(messageInfo.WrapperName, messageInfo.WrapperNamespace);
 0530                writer.WriteAttributeString(JsonGlobals.TypeString, JsonGlobals.ObjectString);
 531            }
 532
 0533            if (messageInfo.ReturnPart != null)
 534            {
 0535                SerializeParameter(writer, messageInfo.ReturnPart, returnValue);
 536            }
 537
 0538            SerializeParameters(writer, messageInfo.BodyParts, parameters);
 539
 0540            if (messageInfo.WrapperName != null)
 541            {
 0542                writer.WriteEndElement();
 543            }
 0544        }
 545
 546        private void SerializeParameter(XmlDictionaryWriter writer, PartInfo part, object graph)
 547        {
 0548            if (part.Description.Multiple)
 549            {
 0550                if (graph != null)
 551                {
 0552                    foreach (object item in (IEnumerable)graph)
 553                    {
 0554                        SerializeParameterPart(writer, part, item);
 555                    }
 556                }
 557            }
 558            else
 559            {
 0560                SerializeParameterPart(writer, part, graph);
 561            }
 0562        }
 563
 564        private void SerializeParameterPart(XmlDictionaryWriter writer, PartInfo part, object graph)
 565        {
 566            try
 567            {
 0568                part.Serializer.WriteObject(writer, graph);
 0569            }
 0570            catch (SerializationException sx)
 571            {
 0572                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
 0573                   SR.Format(SR.SFxInvalidMessageBodyErrorSerializingParameter, part.Description.Namespace, part.Descrip
 574            }
 0575        }
 576
 577        private void SerializeParameters(XmlDictionaryWriter writer, PartInfo[] parts, object[] parameters)
 578        {
 0579            for (int i = 0; i < parts.Length; i++)
 580            {
 0581                PartInfo part = parts[i];
 0582                object graph = parameters[part.Description.Index];
 0583                SerializeParameter(writer, part, graph);
 584            }
 0585        }
 586
 587        private void ValidateTypeObjectAttribute(XmlDictionaryReader reader, bool isRequest)
 588        {
 0589            MessageInfo messageInfo = isRequest ? requestMessageInfo : replyMessageInfo;
 0590            if (messageInfo.WrapperName != null)
 591            {
 0592                if (!IsStartElement(reader, messageInfo.WrapperName, messageInfo.WrapperNamespace))
 593                {
 0594                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.Format(SR.SF
 595                }
 596
 0597                string typeAttribute = reader.GetAttribute(JsonGlobals.TypeString);
 0598                if (!typeAttribute.Equals(JsonGlobals.ObjectString, StringComparison.Ordinal))
 599                {
 0600                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 0601                        new SerializationException(SR.Format(SR.JsonFormatterExpectedAttributeObject, typeAttribute)));
 602                }
 603            }
 0604        }
 605
 606        private void VerifyIsStartElement(XmlDictionaryReader reader, string elementName)
 607        {
 0608            bool foundElement = false;
 0609            while (reader.IsStartElement())
 610            {
 0611                if (IsStartElement(reader, elementName))
 612                {
 0613                    foundElement = true;
 0614                    break;
 615                }
 616                else
 617                {
 0618                    TraceAndSkipElement(reader);
 619                }
 620            }
 621
 0622            if (!foundElement)
 623            {
 0624                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.Format(SR.SFxInv
 625            }
 0626        }
 627
 628        private void VerifyIsStartElement(XmlDictionaryReader reader, XmlDictionaryString elementName, XmlDictionaryStri
 629        {
 0630            bool foundElement = false;
 0631            while (reader.IsStartElement())
 632            {
 0633                if (IsStartElement(reader, elementName, elementNamespace))
 634                {
 0635                    foundElement = true;
 0636                    break;
 637                }
 638                else
 639                {
 0640                    TraceAndSkipElement(reader);
 641                }
 642            }
 643
 0644            if (!foundElement)
 645            {
 0646                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.Format(SR.SFxInv
 647            }
 0648        }
 649
 650        private void WriteVoidReturn(XmlDictionaryWriter writer)
 651        {
 0652            writer.WriteStartElement(JsonGlobals.DString);
 0653            writer.WriteAttributeString(JsonGlobals.TypeString, JsonGlobals.NullString);
 0654            writer.WriteEndElement();
 0655        }
 656
 657
 658        private static void TraceAndSkipElement(XmlReader xmlReader)
 659        {
 660            //if (DiagnosticUtility.ShouldTraceVerbose)
 661            //{
 662            //    TraceUtility.TraceEvent(TraceEventType.Verbose, TraceCode.ElementIgnored, SR.SFxTraceCodeElementIgnore
 663            //}
 0664            xmlReader.Skip();
 0665        }
 666    }
 667}
Generated by: ReportGenerator 5.5.11.0
08/09/2026 - 10:15:50
GitHub | reportgenerator.io

Methods/Properties

.cctor()
.ctor(CoreWCF.Description.OperationDescription,System.Int32,System.Boolean,System.Boolean,System.Boolean,System.String)
IsJsonLocalName(System.Xml.XmlDictionaryReader,System.String)
IsStartElement(System.Xml.XmlDictionaryReader,System.String)
IsStartElement(System.Xml.XmlDictionaryReader,System.Xml.XmlDictionaryString,System.Xml.XmlDictionaryString)
AddHeadersToMessage(CoreWCF.Channels.Message,CoreWCF.Description.MessageDescription,System.Object[],System.Boolean)
DeserializeBody(System.Xml.XmlDictionaryReader,CoreWCF.Channels.MessageVersion,System.String,CoreWCF.Description.MessageDescription,System.Object[],System.Boolean)
GetHeadersFromMessage(CoreWCF.Channels.Message,CoreWCF.Description.MessageDescription,System.Object[],System.Boolean)
SerializeBody(System.Xml.XmlDictionaryWriter,CoreWCF.Channels.MessageVersion,System.String,CoreWCF.Description.MessageDescription,System.Object,System.Object[],System.Boolean)
RecreateDataContractJsonSerializer(System.Runtime.Serialization.Json.DataContractJsonSerializer,System.Type,System.String)
DeserializeBareMessageContract(System.Xml.XmlDictionaryReader,System.Object[],System.Boolean)
DeserializeBodyCore(System.Xml.XmlDictionaryReader,System.Object[],System.Boolean)
DeserializeParameter(System.Xml.XmlDictionaryReader,CoreWCF.Dispatcher.DataContractSerializerOperationFormatter/PartInfo)
DeserializeParameterPart(System.Xml.XmlDictionaryReader,CoreWCF.Dispatcher.DataContractSerializerOperationFormatter/PartInfo)
DeserializeParameters(System.Xml.XmlDictionaryReader,CoreWCF.Dispatcher.DataContractSerializerOperationFormatter/PartInfo[],System.Object[],CoreWCF.Dispatcher.DataContractSerializerOperationFormatter/PartInfo,System.Object&)
SerializeBareMessageContract(System.Xml.XmlDictionaryWriter,System.Object[],System.Boolean)
SerializeBody(System.Xml.XmlDictionaryWriter,System.Object,System.Object[],System.Boolean)
SerializeParameter(System.Xml.XmlDictionaryWriter,CoreWCF.Dispatcher.DataContractSerializerOperationFormatter/PartInfo,System.Object)
SerializeParameterPart(System.Xml.XmlDictionaryWriter,CoreWCF.Dispatcher.DataContractSerializerOperationFormatter/PartInfo,System.Object)
SerializeParameters(System.Xml.XmlDictionaryWriter,CoreWCF.Dispatcher.DataContractSerializerOperationFormatter/PartInfo[],System.Object[])
ValidateTypeObjectAttribute(System.Xml.XmlDictionaryReader,System.Boolean)
VerifyIsStartElement(System.Xml.XmlDictionaryReader,System.String)
VerifyIsStartElement(System.Xml.XmlDictionaryReader,System.Xml.XmlDictionaryString,System.Xml.XmlDictionaryString)
WriteVoidReturn(System.Xml.XmlDictionaryWriter)
TraceAndSkipElement(System.Xml.XmlReader)