C# YAXSerializer.Serialize方法代码示例

        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 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));
 }

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

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

 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);
        }

        /// <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 void AttributeWithDefaultNamespaceAsMemberSerializationTest()
        {
            const string result =
            @"<AttributeWithNamespaceAsMember xmlns:w=""http://example.com/namespace"">
              <w:Member w:name=""Arial"" />
            </AttributeWithNamespaceAsMember>";

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

 public void AudioSampleTest()
 {
     const string result =
     @"<AudioSample>
       <Audio FileName=""filesname.jpg"">base64</Audio>
       <Image FileName=""filesname.jpg"">base64</Image>
     </AudioSample>";
     var serializer = new YAXSerializer(typeof(AudioSample), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects);
     string got = serializer.Serialize(AudioSample.GetSampleInstance());
     Assert.AreEqual(result, got);
 }

        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);
        }

        public void AttributeForClassTest()
        {
            var ser = new YAXSerializer(typeof(AttributeContainerSample));
            string result = ser.Serialize(AttributeContainerSample.GetSampleInstance());

            const string expectedResult =
            @"<container>
              <range from=""1"" to=""3"" />
            </container>";

            Assert.That(expectedResult, Is.EqualTo(result));
        }

        public void TestDoubleMax()
        {
            try
            {
                var ser = new YAXSerializer(typeof (double), YAXExceptionHandlingPolicies.ThrowErrorsOnly,
                    YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects);
                double d = 0.55;
                var xml = ser.Serialize(d);
                var deseredInstance = ser.Deserialize(xml);
                Assert.AreEqual(d, deseredInstance);

                d = Double.MaxValue;
                xml = ser.Serialize(d);
                deseredInstance = ser.Deserialize(xml);
                    // Causes a System.OverflowException {"Value was either too large or too small for a Double."}
                Assert.AreEqual(d, deseredInstance);
            }
            catch (Exception ex)
            {
                Assert.Fail("No exception should have been throwned, but received:" + Environment.NewLine + ex);
            }
        }

        private static void TryYax()
        {
            var obj = CreateFakeObject();
            obj.SetValues();

            var serializer = new YAXSerializer(typeof(Parameters),
                YAXExceptionHandlingPolicies.DoNotThrow,YAXExceptionTypes.Error,
                YAXSerializationOptions.DontSerializeCyclingReferences|YAXSerializationOptions.DontSerializeNullObjects|YAXSerializationOptions.DontSerializePropertiesWithNoSetter);
            var someString = serializer.Serialize(obj);
            File.WriteAllText("yax.xml", someString);

            var back = serializer.DeserializeFromFile("yax.xml");
        }

 public void RectangleSerializationTest()
 {
     const string result =
     @"<RectangleDynamicKnownTypeSample>
       <Rect>
     <Left>10</Left>
     <Top>20</Top>
     <Width>30</Width>
     <Height>40</Height>
       </Rect>
     </RectangleDynamicKnownTypeSample>";
     var serializer = new YAXSerializer(typeof(RectangleDynamicKnownTypeSample), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects);
     string got = serializer.Serialize(RectangleDynamicKnownTypeSample.GetSampleInstance());
     Assert.That(got, Is.EqualTo(result));
 }