Пример #1
0
        public void ShouldSortOneItem()
        {
            Reflector         reflector  = new Reflector();
            Serializer <Item> serializer = reflector.GetSerializer <Item>();;

            Collectible          collectible = new Collectible(1024);
            SortPredicate <Item> predicate   = new SortPredicate <Item>(serializer, x => x.Value);

            collectible.Enqueue(serializer, new Item {
                Value = 1
            });

            Sort.Table(collectible, predicate);
            Assert.That(collectible.At(serializer, 0).AsDynamic().Value, Is.EqualTo(1));
        }
Пример #2
0
        public void ShouldAccessItem()
        {
            Reflector         reflector  = new Reflector();
            Serializer <Item> serializer = reflector.GetSerializer <Item>();;

            Collectible collectible = new Collectible(1024);

            collectible.Enqueue(serializer, new Item {
                Value = 0x1234, Text = "abc"
            });

            dynamic found = collectible.At(serializer, 0);

            Assert.That(found.Value, Is.EqualTo(0x1234));
            Assert.That(found.Text.ToString(), Is.EqualTo("abc"));
        }
Пример #3
0
        public static void Main()
        {
            Stopwatch watch     = new Stopwatch();
            Reflector reflector = new Reflector();

            Collectible       collectible = new Collectible(16 * 1024 * 1024);
            Serializer <Page> serializer  = reflector.GetSerializer <Page>();

            using (TextReader reader = new StreamReader(@"D:\plwiki-20170720-stub-meta-history1.xml"))
                using (XmlStream stream = new XmlStream(reader))
                {
                    watch.Start();

                    foreach (dynamic row in stream.Open("page"))
                    {
                        collectible.Enqueue(serializer, GetPage(row));

                        if (collectible.Count % 1000 == 0)
                        {
                            GC.Collect();
                            Console.WriteLine($"{collectible.Count} {collectible.UsedSize} {collectible.TotalSize} {watch.Elapsed.TotalSeconds:F2}");
                        }
                    }
                }

            Serializer <Revision> byRevision = reflector.GetSerializer <Revision>();

            collectible = Select.Table(collectible, Select.Many(serializer, byRevision, x => x.Revisions));

            GC.Collect();
            Console.WriteLine($"{collectible.Count} {collectible.UsedSize} {collectible.TotalSize} {watch.Elapsed.TotalSeconds:F2}");

            collectible = Sort.Table(collectible, Sort.By(byRevision, x => x.Timestamp).Inverse());

            GC.Collect();
            Console.WriteLine($"{collectible.Count} {collectible.UsedSize} {collectible.TotalSize} {watch.Elapsed.TotalSeconds:F2}");

            for (int i = 0; i < Math.Min(10, collectible.Count); i++)
            {
                Revision revision = collectible.At(byRevision, i).AsDynamic();

                Console.WriteLine($"{i} {revision.Id} {revision.Comment?.Length} {revision.Comment}");
            }

            Console.ReadLine();
        }
Пример #4
0
        public void ShouldSelectOneWithItem()
        {
            Reflector reflector            = new Reflector();
            Serializer <ItemInput>  input  = reflector.GetSerializer <ItemInput>();;
            Serializer <ItemOutput> output = reflector.GetSerializer <ItemOutput>();;

            Collectible collectible = new Collectible(1024);

            collectible.Enqueue(input, new ItemInput {
                Value = 1
            });

            SelectBy by = Select.One(input, output, x => new ItemOutput
            {
                Value = x.Value.ToString()
            });

            collectible = Select.Table(collectible, by);
            Assert.That(collectible.Count, Is.EqualTo(1));
            Assert.That(collectible.At(output, 0).AsDynamic().Value.ToString(), Is.EqualTo("1"));
        }