C# YAXLib.YAXSerializer类代码示例

        public object GetAdaptor(string adaptorName, Type adaptorType, Stream sutFile = null)
        {
            if (adaptors.ContainsKey(adaptorName))
            {
                return adaptors[adaptorName];
            }
            var serializer = new YAXSerializer(adaptorType, YAXExceptionHandlingPolicies.ThrowErrorsOnly, YAXExceptionTypes.Error, YAXSerializationOptions.DontSerializeNullObjects);
            AdaptorImpl adaptor = null;
            try
            {
                string sutXml = null;
                if (sutFile != null)
                {
                    var stramReader = new StreamReader(sutFile);
                    sutXml = stramReader.ReadToEnd();
                }
                else
                {
                    sutXml = File.ReadAllText(SutManager.CurrentSut());
                }

                adaptor = (AdaptorImpl)serializer.Deserialize(sutXml);
            }
            catch (YAXBadlyFormedXML e)
            {
                report.Report("Failed to read sut file", e);
                return null;
            }
            adaptors.Add(adaptorName, adaptor);

            adaptor.Init();

            return adaptor;
        }

        public void CanUseTheDefaultNamespace()
        {
            var ser = new YAXSerializer(typeof(YAXLibMetadataOverriding));

            ser.YaxLibNamespacePrefix = "";
            ser.YaxLibNamespaceUri = "http://namespace.org/sample";
            ser.DimentionsAttributeName = "dm";
            ser.RealTypeAttributeName = "type";

            var sampleInstance = YAXLibMetadataOverriding.GetSampleInstance();
            string result = ser.Serialize(sampleInstance);

            string expected =
            @"<YAXLibMetadataOverriding xmlns=""http://namespace.org/sample"">
              <IntArray dm=""2,3"">
            <Int32>1</Int32>
            <Int32>2</Int32>
            <Int32>3</Int32>
            <Int32>2</Int32>
            <Int32>3</Int32>
            <Int32>4</Int32>
              </IntArray>
              <Obj type=""System.String"">Hello, World!</Obj>
            </YAXLibMetadataOverriding>";
            Assert.That(result, Is.EqualTo(expected));

            var desObj = (YAXLibMetadataOverriding)ser.Deserialize(expected);

            Assert.That(desObj.Obj.ToString(), Is.EqualTo(sampleInstance.Obj.ToString()));
            Assert.That(desObj.IntArray.Length, Is.EqualTo(sampleInstance.IntArray.Length));
        }

        public static PlanDesign LoadPlanDesign(string filePath, out string xmlCurr)
        {
            xmlCurr = null;

            YAXSerializer serializer = new YAXSerializer(typeof(PlanDesign));
            if (string.IsNullOrEmpty(filePath))
                return null;

            try { xmlCurr = File.ReadAllText(filePath); }
            catch (IOException e)
            {
                MyLog.WARNING.WriteLine("Unable to read file " + filePath + " during curriculum loading. " + e.Message);
                return null;
            }

            try
            {
                PlanDesign plan = (PlanDesign)serializer.Deserialize(xmlCurr);
                return plan;
            }
            catch (YAXException e)
            {
                MyLog.WARNING.WriteLine("Unable to deserialize data from " + filePath + " during curriculum loading. " + e.Message);
                return null;
            }
        }

 public void AnotherArraySampleTest()
 {
     const string result =
     @"<!-- This example shows usage of jagged multi-dimensional arrays -->
     <AnotherArraySample xmlns:yaxlib=""http://www.sinairv.com/yaxlib/"">
       <Array1>
     <Array2OfInt32 yaxlib:dims=""2,3"">
       <Int32>1</Int32>
       <Int32>1</Int32>
       <Int32>1</Int32>
       <Int32>1</Int32>
       <Int32>2</Int32>
       <Int32>3</Int32>
     </Array2OfInt32>
     <Array2OfInt32 yaxlib:dims=""3,2"">
       <Int32>3</Int32>
       <Int32>3</Int32>
       <Int32>3</Int32>
       <Int32>4</Int32>
       <Int32>3</Int32>
       <Int32>5</Int32>
     </Array2OfInt32>
       </Array1>
     </AnotherArraySample>";
     var serializer = new YAXSerializer(typeof(AnotherArraySample), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects);
     string got = serializer.Serialize(AnotherArraySample.GetSampleInstance());
     Assert.That(got, Is.EqualTo(result));
 }

 protected Xwt.Widget Read(string Text)
 {
     YAXLib.YAXSerializer Y = new YAXSerializer(typeof(FrameRootNode), YAXExceptionHandlingPolicies.DoNotThrow);
     FrameRootNode Target = (FrameRootNode)Y.Deserialize(Text);
     this.Root = Target.Content.Makeup(this);
     return Root;
 }

 public void CollectionNamespaceGoesThruRecursiveNoContainingElementDeserializationTest()
 {
     var serializer = new YAXSerializer(typeof(CellPhone_CollectionNamespaceGoesThruRecursiveNoContainingElement), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects);
     string got = serializer.Serialize(CellPhone_CollectionNamespaceGoesThruRecursiveNoContainingElement.GetSampleInstance());
     var deserialized = serializer.Deserialize(got) as CellPhone_CollectionNamespaceGoesThruRecursiveNoContainingElement;
     Assert.That(deserialized, Is.Not.Null);
     Assert.That(serializer.ParsingErrors, Has.Count.EqualTo(0));
 }

 public MediaInfoProcess(string pathToVideoFile)
 {
     _pathToVideoFile = pathToVideoFile;
     _isDisposed = false;
     _alreadyExecuted = false;
     _process = new Process();
     _serializer = new YAXSerializer(typeof(MediaInfo), YAXExceptionHandlingPolicies.DoNotThrow);
 }

 public static void Serialize(List<ObjectEffect> effects)
 {
     foreach (var effect in effects)
     {
          YAXSerializer serializer = new YAXSerializer(effect.GetType());
          string contents = serializer.Serialize(effect);
     }
 }

        /// <summary>
        /// Deserializes graph data from a stream
        /// </summary>
        /// <param name="stream">The stream</param>
        /// <returns>The graph data</returns>
		public static List<GraphSerializationData> DeserializeDataFromStream(Stream stream)
        {
            var deserializer = new YAXSerializer(typeof(List<GraphSerializationData>));
            using (var textReader = new StreamReader(stream))
            {
                return (List<GraphSerializationData>)deserializer.Deserialize(textReader);
            }
        }

 public void AttributeWithDefaultNamespaceDeserializationTest()
 {
     var serializer = new YAXSerializer(typeof(AttributeWithNamespace), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects);
     string got = serializer.Serialize(AttributeWithNamespace.GetSampleInstance());
     var deserialized = serializer.Deserialize(got) as AttributeWithNamespace;
     Assert.That(deserialized, Is.Not.Null);
     Assert.That(serializer.ParsingErrors, Has.Count.EqualTo(0));
 }

        public static void SavePlanDesign(PlanDesign design, string filePath, out string xmlResult)
        {
            YAXSerializer serializer = new YAXSerializer(typeof(PlanDesign));

            xmlResult = serializer.Serialize(design);
            File.WriteAllText(filePath, xmlResult);
            MyLog.Writer.WriteLine(MyLogLevel.INFO, "School project saved to: " + filePath);
        }

        public static ProjectBuildDefinition Parse(string xml)
        {
            var yaxSer = new YAXSerializer(typeof(ProjectBuildDefinition),
                YAXExceptionHandlingPolicies.DoNotThrow,
                YAXExceptionTypes.Ignore,
                YAXSerializationOptions.DontSerializeNullObjects);

            return yaxSer.Deserialize(xml) as ProjectBuildDefinition;
        }

        /// <summary>
        /// Serializes graph data list to a stream
        /// </summary>
        /// <param name="stream">The destination stream</param>
        /// <param name="modelsList">The graph data</param>
		public static void SerializeDataToStream(Stream stream, List<GraphSerializationData> modelsList)
        {
            var serializer = new YAXSerializer(typeof(List<GraphSerializationData>));
            using (var textWriter = new StreamWriter(stream))
            {
                serializer.Serialize(modelsList, textWriter);
                textWriter.Flush();
            }
        }

        public void AttributeNamespaceSerializationTest()
        {
            const string result = "<AttributeNamespaceSample xmlns:ns=\"http://namespaces.org/ns\" xmlns=\"http://namespaces.org/default\">" + @"
              <Attribs " + "attrib=\"value\" ns:attrib2=\"value2\"" + @" />
            </AttributeNamespaceSample>";

            var serializer = new YAXSerializer(typeof(AttributeNamespaceSample), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects);
            string got = serializer.Serialize(AttributeNamespaceSample.GetSampleInstance());
            Assert.That(got, Is.EqualTo(result));
        }

        public static string ParseAndRegenerateXml(string xml)
        {
            var project = Parse(xml);

            var yaxSer = new YAXSerializer(typeof(ProjectBuildDefinition),
                YAXExceptionHandlingPolicies.DoNotThrow,
                YAXExceptionTypes.Ignore,
                YAXSerializationOptions.DontSerializeNullObjects);

            return yaxSer.Serialize(project);
        }