예제 #1
0
        static void SetupBencher(IReactiveCommand command, string name = null)
        {
            Bencher     bencher      = null;
            IDisposable subscription = null;

            subscription = command.IsExecuting.Subscribe(x => HandleBencher(x, ref bencher, name, subscription));
        }
예제 #2
0
 static void HandleBencher(bool b, ref Bencher bencher, string name, IDisposable subscription)
 {
     if (b)
     {
         bencher = new Bencher("UICommand", name ?? "TODO");
     }
     else
     {
         bencher?.Dispose();
         subscription?.Dispose();
     }
 }
예제 #3
0
        public static void Run()
        {
            const string twitterPath   = @"C:\Projects\C#\Entia\Entia.Test\Resources\twitter.json";
            var          withReference = Settings.Default.With(Features.Reference);
            var          withAbstract  = Settings.Default.With(Features.Abstract);
            var          withAll       = Settings.Default.With(Features.All);

            var jsonA  = @"{""$t"":3}";
            var valueA = Serialization.Parse(jsonA, withAbstract).Or(Node.Null);
            var jsonB  = Serialization.Generate(valueA);
            var jsonC  = @"{""$t"":3,""$v"":5}";
            var valueC = Serialization.Parse(jsonC, withAbstract).Or(Node.Null);
            var jsonD  = Serialization.Generate(valueC);
            var node1  = Serialization.Parse(@"""<a href=\""http://twitter.com\"" rel=\""nofollow\"">Twitter Web Client</a>""");

            var settings = new JsonSerializerSettings
            {
                ReferenceLoopHandling      = ReferenceLoopHandling.Serialize,
                TypeNameHandling           = TypeNameHandling.Auto,
                PreserveReferencesHandling = PreserveReferencesHandling.Objects,
                Formatting             = Formatting.None,
                ObjectCreationHandling = ObjectCreationHandling.Replace
            };
            var twitterJson   = File.ReadAllText(twitterPath);
            var twitterBytes  = File.ReadAllBytes(twitterPath);
            var twitterNode   = Serialization.Parse(twitterJson).Or(Node.Null);
            var twitterObject = JsonConvert.DeserializeObject <JObject>(twitterJson, settings);

            void Test <T>(in T value, out string json, out Node node, out T instance, Settings?settings = null)
            {
                json     = Json.Serialization.Serialize(value, settings);
                node     = Serialization.Parse(json, settings).Or(Node.Null);
                instance = Json.Serialization.Instantiate <T>(node, settings);
            }

            Test(new Cyclic(), out var json4, out var node4, out var value4, withAll);
            Test <object>(new Cyclic(), out var json4B, out var node4B, out var value4B, withAll);
            Test <object>(new Dictionary <object, object?>
            {
                { 1, "2" },
                { "3", null },
                { 4, "5" },
                { DateTime.Now, TimeSpan.MaxValue }
            }, out var json5, out var node5, out var value5, withAbstract);
            Test(new Dictionary <int, int> {
                { 1, -1 }, { 2, -2 }
            }, out var json6, out var node6, out var value6);
            Test <object>(1, out var json7, out var node7, out var value7, withAbstract);

            var dictionary = new Dictionary <object, object>();

            dictionary[1]           = dictionary;
            dictionary[1f]          = dictionary;
            dictionary[1uL]         = dictionary;
            dictionary[1d]          = 1f;
            dictionary[typeof(int)] = typeof(int[]);
            Test(dictionary, out var json8, out var node8, out var value8, withAll);

            Test(new Stack <int>(new int[] { 1, 2, 3 }), out var json9, out var node9, out var value9);
            Test(new Queue <int>(new int[] { 1, 2, 3 }), out var json10, out var node10, out var value10);
            Test(new List <int>(new int[] { 1, 2, 3 }), out var json11, out var node11, out var value11);
            Test(new int[] { 1, 2, 3 }, out var json12, out var node12, out var value12);
            Test(new Queue(new object[] { 1, "2", 3L }), out var json13, out var node13, out var value13, withAbstract);
            Test(new SortedDictionary <int, int> {
                { 1, 2 }, { 3, 4 }
            }, out var json14, out var node14, out var value14);
            Test(new ConcurrentDictionary <int, int>(new[] { new KeyValuePair <int, int>(1, 2), new KeyValuePair <int, int>(3, 4) }), out var json15, out var node15, out var value15);
            Test(Features.Abstract, out var json16, out var node16, out var value16);
            Test(Null.Some(Features.Abstract), out var json17, out var node17, out var value17);
            Test(Null.None <Features>(), out var json18, out var node18, out var value18);
            Test(Option.None().AsOption <int>(), out var json19, out var node19, out var value19);
            Test(Option.Some(32), out var json20, out var node20, out var value20);

            var anonymous = new
            {
                a  = Option.Some(32),
                b1 = Null.None <Features>(),
                b2 = Null.None <Features>(),
                b3 = Null.None <Features>(),
                c  = Features.Abstract,
            };

            Test(anonymous, out var json21, out var node21, out var value21);
            Test <object>(anonymous, out var json22, out var node22, out var value22, withAll);
            Test(anonymous.GetType(), out var json23, out var node23, out var value23, withAbstract);
            Test(new Dictionary <string, object> {
                { "boba", "fett" }
            }, out var json24, out var node24, out var value24, withAll);
            Test(new BitArray(new byte[] { 0, 1, 2, 3, 4, 5 }), out var json25, out var node25, out var value25);
            Test(new HashSet <byte>(new byte[] { 0, 1, 2, 3, 4, 5 }), out var json26, out var node26, out var value26);
            Test(new HashSet <Features>(new[] { Features.Abstract, Features.Reference }), out var json27, out var node27, out var value27);
            Test(new[] { Features.Abstract, Features.Reference }, out var json28, out var node28, out var value28);

            void SerializeA <T>(T value)
            {
                var json = Json.Serialization.Serialize(new Wrapper <T> {
                    Value = value
                }, withAll);

                value = Json.Serialization.Deserialize <Wrapper <T> >(json, withAll).OrDefault().Value;
            }

            void SerializeB <T>(T value)
            {
                var json = JsonConvert.SerializeObject(new Wrapper <T> {
                    Value = value
                }, settings);

                value = JsonConvert.DeserializeObject <Wrapper <T> >(json, settings).Value;
            }

            string generated;

            void ParseA() => Serialization.Parse(twitterJson);
            void ParseB() => JsonConvert.DeserializeObject <JObject>(twitterJson, settings);
            void GenerateA() => generated = Serialization.Generate(twitterNode);
            void GenerateB() => generated = JsonConvert.SerializeObject(twitterObject, settings);
            void IntNumberA() => SerializeA(1);
            void ObjectNumberA() => SerializeA <object>(1);
            void CyclicA() => SerializeA(new Cyclic());
            void ObjectCyclicA() => SerializeA <object>(new Cyclic());
            void IntDictionaryA() => SerializeA(new Dictionary <int, int> {
                { 1, -1 }, { 2, -2 }, { 3, -3 }
            });
            void IntObjectDictionaryA() => SerializeA(new Dictionary <int, object> {
                { 1, -1 }, { 2, -2 }, { 3, -3 }
            });
            void ObjectIntDictionaryA() => SerializeA(new Dictionary <object, int> {
                { 1, -1 }, { 2, -2 }, { 3, -3 }
            });
            void ObjectDictionaryA() => SerializeA(new Dictionary <object, object> {
                { 1, -1 }, { 2, -2 }, { 3, -3 }
            });
            void LargeArrayA() => SerializeA(new ulong[256]);

            void IntNumberB() => SerializeB(1);
            void ObjectNumberB() => SerializeB <object>(1);
            void CyclicB() => SerializeB(new Cyclic());
            void ObjectCyclicB() => SerializeB <object>(new Cyclic());
            void IntDictionaryB() => SerializeB(new Dictionary <int, int> {
                { 1, -1 }, { 2, -2 }, { 3, -3 }
            });
            void IntObjectDictionaryB() => SerializeB(new Dictionary <int, object> {
                { 1, TimeSpan.MaxValue }, { 2, TimeSpan.MaxValue }, { 3, TimeSpan.MaxValue }
            });
            void ObjectIntDictionaryB() => SerializeB(new Dictionary <object, int> {
                { 1, -1 }, { 2, -2 }, { 3, -3 }
            });
            void ObjectDictionaryB() => SerializeB(new Dictionary <object, object> {
                { DateTime.Now, TimeSpan.MaxValue }, { DateTime.Now, TimeSpan.MaxValue }, { DateTime.Now, TimeSpan.MaxValue }
            });
            void LargeArrayB() => SerializeB(new ulong[256]);

            while (true)
            {
                Bencher.Measure(ParseA, new Action[]
                {
                    ParseB,
                    GenerateA,
                    GenerateB,
                }, 100, 1);

                Console.WriteLine();
                Bencher.Measure(IntNumberA, new Action[]
                {
                    ObjectNumberA,
                    CyclicA,
                    ObjectCyclicA,
                    IntDictionaryA,
                    IntObjectDictionaryA,
                    ObjectIntDictionaryA,
                    ObjectDictionaryA,
                    LargeArrayA,

                    IntNumberB,
                    ObjectNumberB,
                    CyclicB,
                    ObjectCyclicB,
                    IntDictionaryB,
                    IntObjectDictionaryB,
                    ObjectIntDictionaryB,
                    ObjectDictionaryB,
                    LargeArrayB,
                }, 1000);
                Console.WriteLine();
            }
        }