Example #1
0
        /// <summary>
        /// 将文档字符串反序列化到指定的对象中。
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="textFormatter">文档反序列化器</param>
        /// <param name="textReader">文档字符串读取器</param>
        /// <param name="obj">对象</param>
        public static void DeserializeTo <T>(this ITextFormatter textFormatter, TextReader textReader, T obj)
        {
            IDataWriter dataWriter;

            try
            {
                dataWriter = RWHelper.CreateRW(obj);
            }
            catch (NotSupportedException)
            {
                dataWriter = RWHelper.CreateWriter <T>();

                RWHelper.SetContent(dataWriter, obj);
            }

            if (dataWriter is IDataWriter <string> nameWriter)
            {
                DeserializeTo(textFormatter, textReader, nameWriter);
            }
            else if (dataWriter is IDataWriter <int> indexWriter)
            {
                DeserializeTo(textFormatter, textReader, indexWriter);
            }
            else
            {
                var invoker = new DeserializeToAsInvoker(textFormatter, textReader, dataWriter);

                AsHelper.GetInstance(dataWriter).Invoke(invoker);
            }
        }
Example #2
0
        public void CreateTest()
        {
            AreEqual(RWHelper.CreateRW(new Dictionary <string, object>()).GetType().Name, "DictionaryRW`3");
            AreEqual(RWHelper.CreateRW(new ReadOnlyDictionary <string, object>(new Dictionary <string, object>())).GetType().Name, "DictionaryRW`3");
            AreEqual(RWHelper.CreateRW(new ConcurrentDictionary <string, object>()).GetType().Name, "DictionaryRW`3");
            AreEqual(RWHelper.CreateRW(new SortedDictionary <string, object>()).GetType().Name, "DictionaryRW`3");
            AreEqual(RWHelper.CreateRW(new SortedList <string, object>()).GetType().Name, "DictionaryRW`3");

            AreEqual(RWHelper.CreateRW(new List <object>()).GetType().Name, "ListRW`2");
            AreEqual(RWHelper.CreateRW(new ReadOnlyCollection <object>(new List <object>())).GetType().Name, "ListRW`2");
            AreEqual(RWHelper.CreateRW(new Collection <object>()).GetType().Name, "ListRW`2");

            AreEqual(RWHelper.CreateRW(new LinkedList <object>()).GetType().Name, "CollectionRW`2");
            AreEqual(RWHelper.CreateRW(new HashSet <object>()).GetType().Name, "CollectionRW`2");
            AreEqual(RWHelper.CreateRW(new SortedSet <object>()).GetType().Name, "CollectionRW`2");

            AreEqual(RWHelper.CreateRW(new Hashtable()).GetType().Name, "DictionaryRW`1");
            AreEqual(RWHelper.CreateRW(new SortedList()).GetType().Name, "DictionaryRW`1");
            AreEqual(RWHelper.CreateRW(new OrderedDictionary()).GetType().Name, "DictionaryRW`1");
            AreEqual(RWHelper.CreateRW(new ListDictionary()).GetType().Name, "DictionaryRW`1");

            AreEqual(RWHelper.CreateRW(new ArrayList()).GetType().Name, "ListRW`1");
            AreEqual(RWHelper.CreateRW(new StringCollection()).GetType().Name, "ListRW`1");


            AreEqual(RWHelper.CreateRW(new DataSet()).GetType().Name, "DataSetRW`1");
            AreEqual(RWHelper.CreateRW(new DataTable()).GetType().Name, "DataTableRW`1");
            AreEqual(RWHelper.CreateRW(new DataTable().NewRow()).GetType().Name, "DataRowRW`1");

            AreEqual(GetCSharpName(RWHelper.CreateRW(new int[0]).GetType()), "Swifter.RW.ArrayRW<int>");
            AreEqual(GetCSharpName(RWHelper.CreateRW(new int[0, 0]).GetType()), "Swifter.RW.MultiDimArray<int[,],int>.FirstRW");
            AreEqual(GetCSharpName(RWHelper.CreateRW(new int[0, 0, 0]).GetType()), "Swifter.RW.MultiDimArray<int[,,],int>.FirstRW");


            AreEqual(RWHelper.CreateReader(new List <object>().GetEnumerator().AsEnumerable()).GetType().Name, "EnumeratorReader`2");
            AreEqual(RWHelper.CreateReader(new List <object>().GetEnumerator()).GetType().Name, "EnumeratorReader`2");
            AreEqual(RWHelper.CreateReader(new ArrayList().GetEnumerator().AsEnumerable()).GetType().Name, "EnumeratorReader`1");
            AreEqual(RWHelper.CreateReader(new ArrayList().GetEnumerator()).GetType().Name, "EnumeratorReader`1");

            AreEqual(RWHelper.CreateReader(new DataTable().CreateDataReader()).GetType().Name, "DbDataReaderReader");

            AreEqual(
                RWHelper.CreateItemRW(RWHelper.CreateRW(new { Data = new Dictionary <string, object>() }).As <string>(), "Data").GetType().Name,
                "DictionaryRW`3");

            AreEqual(
                RWHelper.CreateItemReader(RWHelper.CreateRW(new { Data = new DataTable().CreateDataReader() }).As <string>(), "Data").GetType().Name,
                "DbDataReaderReader");

            Catch <NotSupportedException>(() => RWHelper.CreateRW("err"));

            var asTester = (IAsDataRW)RWHelper.CreateRW(new int[0]).As <string>();

            Catch <SuccessException>(() => asTester.InvokeTIn(new AsTestInvoker <int>()));
            Catch <SuccessException>(() => asTester.InvokeTOut(new AsTestInvoker <string>()));
        }
Example #3
0
        public void ReferencingTest()
        {
            var obj = new { Id = 123, Name = "Dogwei", Obj = (object)null };
            var arr = new object[2];

            arr[0] = new { Id = 123 };
            arr[1] = arr[0];

            RWHelper.CreateRW(obj).As <string>()["Obj"].DirectWrite(obj);

            AreEqual(
                JsonFormatter.SerializeObject(obj, JsonFormatterOptions.LoopReferencingNull),
                "{\"Id\":123,\"Name\":\"Dogwei\",\"Obj\":null}"
                );

            AreEqual(
                JsonFormatter.SerializeObject(obj, JsonFormatterOptions.MultiReferencingNull),
                "{\"Id\":123,\"Name\":\"Dogwei\",\"Obj\":null}"
                );

            AreEqual(
                JsonFormatter.SerializeObject(obj, JsonFormatterOptions.MultiReferencingReference),
                "{\"Id\":123,\"Name\":\"Dogwei\",\"Obj\":{\"$ref\":\"#\"}}"
                );

            Catch <JsonOutOfDepthException>(() => JsonFormatter.SerializeObject(obj));
            Catch <JsonLoopReferencingException>(() => JsonFormatter.SerializeObject(obj, JsonFormatterOptions.LoopReferencingException));

            AreEqual(
                JsonFormatter.SerializeObject(arr, JsonFormatterOptions.LoopReferencingNull),
                "[{\"Id\":123},{\"Id\":123}]"
                );

            AreEqual(
                JsonFormatter.SerializeObject(arr, JsonFormatterOptions.MultiReferencingNull),
                "[{\"Id\":123},null]"
                );

            AreEqual(
                JsonFormatter.SerializeObject(arr, JsonFormatterOptions.MultiReferencingReference),
                "[{\"Id\":123},{\"$ref\":\"#/0\"}]"
                );

            JsonFormatter.SerializeObject(arr);
            JsonFormatter.SerializeObject(arr, JsonFormatterOptions.LoopReferencingException);

            AreEqual(
                JsonFormatter.SerializeObject(ValueInterface <DataTable> .ReadValue(ValueCopyer.ValueOf(arr)), JsonFormatterOptions.MultiReferencingNull),
                "[{\"Id\":123},{\"Id\":123}]"
                );

            AreEqual(
                JsonFormatter.SerializeObject(ValueInterface <DataTable> .ReadValue(ValueCopyer.ValueOf(arr)).CreateDataReader(), JsonFormatterOptions.MultiReferencingNull),
                "[{\"Id\":123},{\"Id\":123}]"
                );

            AreEqual(
                JsonFormatter.SerializeObject(Enumerable.Range(0, 10), JsonFormatterOptions.MultiReferencingNull),
                "[0,1,2,3,4,5,6,7,8,9]"
                );

            var mar = new object[, ] {
                { arr[0], arr[0] }, { arr[0], arr[0] }
            };

            AreEqual(
                JsonFormatter.SerializeObject(mar, JsonFormatterOptions.LoopReferencingNull),
                "[[{\"Id\":123},{\"Id\":123}],[{\"Id\":123},{\"Id\":123}]]"
                );

            AreEqual(
                JsonFormatter.SerializeObject(mar, JsonFormatterOptions.MultiReferencingNull),
                "[[{\"Id\":123},null],[null,null]]"
                );

            AreEqual(
                JsonFormatter.SerializeObject(mar, JsonFormatterOptions.MultiReferencingReference),
                "[[{\"Id\":123},{\"$ref\":\"#/0/0\"}],[{\"$ref\":\"#/0/0\"},{\"$ref\":\"#/0/0\"}]]"
                );

            JsonFormatter.SerializeObject(mar);
            JsonFormatter.SerializeObject(mar, JsonFormatterOptions.LoopReferencingException);

            var dic2 = JsonFormatter.DeserializeObject <object[]>("[{\"Id\":123},{\"$ref\":\"#/0\"}]");

            AreEqual(JsonFormatter.SerializeObject(dic2[1]), "{\"$ref\":\"#/0\"}");

            var mar2 = JsonFormatter.DeserializeObject <object[, ]>("[[{\"Id\":123},{\"$ref\":\"#/0/0\"}],[{\"$ref\":\"#/0/0\"},{\"$ref\":\"#/0/0\"}]]", JsonFormatterOptions.MultiReferencingReference);

            AreEqual(mar2[0, 0], mar2[0, 1]);
            AreEqual(mar2[1, 0], mar2[0, 1]);
            AreEqual(mar2[1, 0], mar2[1, 1]);
        }