Sage.Integration.Northwind.Feeds.SyncFeed.ReadXml C# (CSharp) Метод

        public void ReadXml(System.Xml.XmlReader reader, Type payloadType)
        {
            reader.MoveToContent();
            if ((reader.NodeType == System.Xml.XmlNodeType.Element)
                && (reader.LocalName == "feed")
                && (reader.NamespaceURI == Namespaces.atomNamespace))
            {
                bool reading = true;
                while (reading)
                {
                    if (reader.NodeType == System.Xml.XmlNodeType.Element)
                    {
                        switch(reader.LocalName)
                        {
                            case "title":
                                reading = reader.Read();
                                if (reader.NodeType == System.Xml.XmlNodeType.Text)
                                    this.Title = reader.Value;
                                break;
                            case "id":
                                reading = reader.Read();
                                if (reader.NodeType == System.Xml.XmlNodeType.Text)
                                    this.Id = reader.Value;
                                break;
                            case "entry":
                                SyncFeedEntry entry = new SyncFeedEntry();
                                entry.ReadXml(reader, payloadType);
                                this.Entries.Add(entry);
                                break;
                            case "digest":
                                System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(SyncFeedDigest));
                                object obj = serializer.Deserialize(reader);
                                if (obj is SyncFeedDigest)
                                    this.Digest = obj as SyncFeedDigest;
                                break;
                            case "itemsPerPage":
                                reading = reader.Read();
                                if (reader.NodeType == System.Xml.XmlNodeType.Text)
                                {
                                    IItemsPerPageElement itemsPerPageElement = FeedComponentFactory.Create<IItemsPerPageElement>();
                                    itemsPerPageElement.LoadXmlValue(reader.Value);
                                }
                                break;
                            case "startIndex":
                                reading = reader.Read();
                                if (reader.NodeType == System.Xml.XmlNodeType.Text)
                                {
                                    IStartIndexElement startIndexElement = FeedComponentFactory.Create<IStartIndexElement>();
                                    startIndexElement.LoadXmlValue(reader.Value);
                                }
                                break;
                            case "totalResults":
                                reading = reader.Read();
                                if (reader.NodeType == System.Xml.XmlNodeType.Text)
                                {
                                    ITotalResultsElement totalResultsElement = FeedComponentFactory.Create<ITotalResultsElement>();
                                    totalResultsElement.LoadXmlValue(reader.Value);
                                }
                                break;

                            default:
                                reading = reader.Read();
                                break;
                        }

                    }
                    else{
                        reading = reader.Read();
                    }
                }
            }
        }

        public void DoWork(IRequest request)
        {
            // If an asyncState object already exists, an exception is thrown as the performer only accepts
            // one call after each other. The Request receiver has to manage a queued execution.

            // Before calling the performers execution implementation method a new AsyncState object is created
            // and set to an initial tracking state.

            lock (_asyncStateObj)
            {
                if (null != _asyncStateObj.Tracking)
                    throw new InvalidOperationException("The performer cannot be executed because it is already running.");

                SyncTracking tracking = new SyncTracking();
                tracking.ElapsedSeconds = 1;
                tracking.Phase = TrackingPhase.INIT;
                tracking.PhaseDetail = "Tracking Id was: " + _requestContext.TrackingId.ToString();
                tracking.PollingMillis = 100;
                tracking.RemainingSeconds = 100;

                _asyncStateObj.Tracking = tracking;
            }

            // *** Initialization for the async execution ***
            // - Read Feed from request stream.
            // - Read trackingId from request URL

            // convert tracking ID from request to type Guid
            string strTrackingId = request.Uri.TrackingID;
            if (String.IsNullOrEmpty(strTrackingId))
                throw new RequestException("TrackingId is missing");

            GuidConverter converter = new GuidConverter();
            this.TrackingId = (Guid)converter.ConvertFrom(strTrackingId);

            //read feed
            SyncFeed feed = new SyncFeed();
            XmlReader reader = XmlReader.Create(request.Stream);
            feed.ReadXml(reader, ResourceKindHelpers.GetPayloadType(_requestContext.ResourceKind));

            // *** Do work asynchronously ***
            _asyncPerformer = new InternalAsyncPerformer(this);
            _asyncPerformer.DoWork(_requestContext.Config, feed);

            // *** set the tracking to the request response ***
            this.GetTrackingState(request);
        }