C# XmlSerializer.SerializeToXElemet方法代码示例

        public JsonResult ApplyPattern(int id, SequencingPattern pattern, int data)
        {
            var node = _Storage.GetNode(id);
            var xml = new XmlSerializer(typeof(Sequencing));

            var xelement = id == 0 ? _CurrentCourse.Sequencing : node.Sequencing;

            var sequencing = xelement == null ? new Sequencing() : (Sequencing)xml.DeserializeXElement(xelement);

            switch (pattern)
            {
                case SequencingPattern.ControlChapterSequencingPattern:
                    sequencing = SequencingPatternManager.ApplyControlChapterSequencing(sequencing);
                    break;
                case SequencingPattern.RandomSetSequencingPattern:
                    sequencing = SequencingPatternManager.ApplyRandomSetSequencingPattern(sequencing, data);
                    break;
                case SequencingPattern.OrganizationDefaultSequencingPattern:
                    sequencing = SequencingPatternManager.ApplyDefaultChapterSequencing(sequencing);
                    break;
            }

            if (id == 0)
            {
                _CurrentCourse.Sequencing = xml.SerializeToXElemet(sequencing);
                _Storage.UpdateCourse(_CurrentCourse.Id, _CurrentCourse);
            }
            else
            {
                node.Sequencing = xml.SerializeToXElemet(sequencing);
                _Storage.UpdateNode(id, node);
            }

            return Json(new { status = true });
        }

        protected void ProcessItem(Item item, Node parent)
        {
            var xml = new XmlSerializer(typeof(Sequencing));

            var node = new Node
            {
                CourseId = this.course.Id,
                Name = item.Title,
                IsFolder = item.IsParent,
                ParentId = (parent != null ? (int?)parent.Id : null),
                Sequencing = xml.SerializeToXElemet(item.Sequencing)
            };

            this.courseStorage.AddNode(node);

            if (item.IsParent && item.Items.Count > 0)
            {
                foreach (var subitem in item.Items)
                {
                    this.ProcessItem(subitem, node);
                }
            }
            else
            {   
                if (item.IdentifierRef != null)
                {
                    var resource = this.manifest.Resources.ResourcesList.Where(r => r.Identifier == item.IdentifierRef).FirstOrDefault();

                    if (resource != null)
                    {
                        this.ProcessResource(node, resource);

                        return;
                    }
                }
            }
        }

        public JsonResult SaveProperties(int nodeId, string type)
        {
            var node = _Storage.GetNode(nodeId);
            var xml = new XmlSerializer(typeof(Sequencing));

            var xelement = nodeId == 0 ? _CurrentCourse.Sequencing : node.Sequencing;

            var sequencing = xelement == null ? new Sequencing() : (Sequencing)xml.DeserializeXElement(xelement);
            
            object model;

            if (type == "ControlMode")
            {
                model = new ControlMode();
                TryUpdateModel(model as ControlMode);
                sequencing.ControlMode = model as ControlMode;
            }
            else if (type == "LimitConditions")
            {
                model = new LimitConditions();
                TryUpdateModel(model as LimitConditions);
                sequencing.LimitConditions = model as LimitConditions;
            }
            else if (type == "ConstrainedChoiceConsiderations")
            {
                model = new ConstrainedChoiceConsiderations();
                TryUpdateModel(model as ConstrainedChoiceConsiderations);
                sequencing.ConstrainedChoiceConsiderations = model as ConstrainedChoiceConsiderations;
            }
            else if (type == "RandomizationControls")
            {
                model = new RandomizationControls();
                TryUpdateModel(model as RandomizationControls);
                sequencing.RandomizationControls = model as RandomizationControls;
            }
            else if (type == "DeliveryControls")
            {
                model = new DeliveryControls();
                TryUpdateModel(model as DeliveryControls);
                sequencing.DeliveryControls = model as DeliveryControls;
            }
            else if (type == "RollupRules")
            {
                model = new RollupRules();
                TryUpdateModel(model as RollupRules);
                sequencing.RollupRules = model as RollupRules;
            }
            else if (type == "RollupConsiderations")
            {
                model = new RollupConsiderations();
                TryUpdateModel(model as RollupConsiderations);
                sequencing.RollupConsiderations = model as RollupConsiderations;
            }
            else
            {
                throw new NotImplementedException();
            }

            if(nodeId == 0)
            {
                _CurrentCourse.Sequencing = xml.SerializeToXElemet(sequencing);
                _Storage.UpdateCourse(_CurrentCourse.Id, _CurrentCourse);
            }
            else
            {
                node.Sequencing = xml.SerializeToXElemet(sequencing);
                _Storage.UpdateNode(nodeId, node);
            }
            

            return Json(new { status = true });
        }

 public void EditPropertiesTest([Values("ControlMode",
                                        "LimitConditions",
                                        "ConstrainedChoiceConsiderations",
                                        "RandomizationControls",
                                        "DeliveryControls",
                                        "RollupRules",
                                        "RollupConsiderations")]
                                string type)
 {
     try
     {
         // create new node with name "SomeNode", id=ID, courseId=1, and add it to storage
         this.createNode();
         // create new xml serializer
         var xml = new XmlSerializer(typeof(Sequencing));
         // get Sequencing from node with id = ID
         var xelement = this.Storage.GetNode(ID).Sequencing;
         // deserialize sequencing from xelement
         var sequencing = xelement == null ? new Sequencing() : (Sequencing)xml.DeserializeXElement(xelement);
         // new model
         object model;
         // for different type initialise sequencing property
         if (type == "ControlMode")
         {
             model = new ControlMode();
             
             //TryUpdateModel(model as ControlMode);
             sequencing.ControlMode = model as ControlMode;
         }
         else if (type == "LimitConditions")
         {
             model = new LimitConditions();
             //TryUpdateModel(model as LimitConditions);
             sequencing.LimitConditions = model as LimitConditions;
         }
         else if (type == "ConstrainedChoiceConsiderations")
         {
             model = new ConstrainedChoiceConsiderations();
             //TryUpdateModel(model as ConstrainedChoiceConsiderations);
             sequencing.ConstrainedChoiceConsiderations = model as ConstrainedChoiceConsiderations;
         }
         else if (type == "RandomizationControls")
         {
             model = new RandomizationControls();
             //TryUpdateModel(model as RandomizationControls);
             sequencing.RandomizationControls = model as RandomizationControls;
         }
         else if (type == "DeliveryControls")
         {
             model = new DeliveryControls();
             //TryUpdateModel(model as DeliveryControls);
             sequencing.DeliveryControls = model as DeliveryControls;
         }
         else if (type == "RollupRules")
         {
             model = new RollupRules();
             //TryUpdateModel(model as RollupRules);
             sequencing.RollupRules = model as RollupRules;
         }
         else if (type == "RollupConsiderations")
         {
             model = new RollupConsiderations();
             //TryUpdateModel(model as RollupConsiderations);
             sequencing.RollupConsiderations = model as RollupConsiderations;
         }
         else
         {
             throw new NotImplementedException();
         }
         // serialize sequencing
         xelement = xml.SerializeToXElemet(sequencing);
         // update node
         this.Storage.UpdateNode(ID, this.Storage.GetNode(ID));
     }
     catch (Exception ex)
     {
         Assert.Fail(ex.Message);
     }
 }

 public void ApplyPatternTest([Values(SequencingPattern.ControlChapterSequencingPattern, 
                                      SequencingPattern.RandomSetSequencingPattern, 
                                      SequencingPattern.OrganizationDefaultSequencingPattern)]
                              SequencingPattern pattern)
 {
     try
     {
         // create new node with name "SomeNode", id=ID, courseId=1, and add it to storage
         this.createNode();
         // get node with id = ID
         var node = this.Storage.GetNode(ID);
         // create new xml serializer
         var xml = new XmlSerializer(typeof(Sequencing));
         // get Sequencing from node with id = ID
         var xelement = this.Storage.GetNode(ID).Sequencing;
         // deserialize sequencing from xelement
         var sequencing = xelement == null ? new Sequencing() : (Sequencing)xml.DeserializeXElement(xelement);
         // for different patterns type apply different patterns
         switch (pattern)
         {
             case SequencingPattern.ControlChapterSequencingPattern:
                 sequencing = SequencingPatternManager.ApplyControlChapterSequencing(sequencing);
                 break;
             case SequencingPattern.RandomSetSequencingPattern:
                 sequencing = SequencingPatternManager.ApplyRandomSetSequencingPattern(sequencing, 1);
                 break;
             case SequencingPattern.OrganizationDefaultSequencingPattern:
                 sequencing = SequencingPatternManager.ApplyDefaultChapterSequencing(sequencing);
                 break;
         }
         // serialize sequencing
         node.Sequencing = xml.SerializeToXElemet(sequencing);
         // try update node
         this.Storage.UpdateNode(ID, node);
     }
     catch (Exception ex)
     {
         Assert.Fail(ex.Message);
     }
 }

        public JsonResult ApplyPattern(int id, SequencingPattern pattern, int data)
        {
            var node = this.storage.GetNode(id);
            var xml = new XmlSerializer(typeof(Sequencing));

            var xelement = id == 0 ? this.currentCourse.Sequencing : node.Sequencing;

            var sequencing = xelement == null ? new Sequencing() : (Sequencing)xml.DeserializeXElement(xelement);

            switch (pattern)
            {
                case SequencingPattern.ControlChapterSequencingPattern:
                    sequencing = SequencingPatternManager.ApplyControlChapterSequencing(sequencing);
                    break;
                case SequencingPattern.RandomSetSequencingPattern:
                    sequencing = SequencingPatternManager.ApplyRandomSetSequencingPattern(sequencing, data);
                    break;
                case SequencingPattern.OrganizationDefaultSequencingPattern:
                    sequencing = SequencingPatternManager.ApplyDefaultChapterSequencing(sequencing);
                    break;
            }

            if (id == 0)
            {
                this.currentCourse.Sequencing = xml.SerializeToXElemet(sequencing);
                this.storage.UpdateCourse(this.currentCourse.Id, this.currentCourse);

                // logic to update all nodes sequencing
                var courseNodes = this.storage.GetAllNodes(this.currentCourse.Id);
                foreach (var courseNode in courseNodes)
                {
                    courseNode.Sequencing = xml.SerializeToXElemet(sequencing);
                    this.storage.UpdateNode(courseNode.Id, courseNode);
                }
            }
            else
            {
                node.Sequencing = xml.SerializeToXElemet(sequencing);
                this.storage.UpdateNode(id, node);
            }

            return Json(new { status = true });
        }

        private void ApplyDefaultPattern(Course course)
        {
            var xml = new XmlSerializer(typeof(Sequencing));

            var xelement = course.Sequencing;

            var sequencing = xelement == null ? new Sequencing() : (Sequencing)xml.DeserializeXElement(xelement);


            sequencing = SequencingPatternManager.ApplyDefaultChapterSequencing(sequencing);

            course.Sequencing = xml.SerializeToXElemet(sequencing);
            this.storage.UpdateCourse(course.Id, course);
        }