C# Queue.GetEnumerator方法代码示例

    public bool PosTest1()
    {
        bool retVal = true;
        TestLibrary.TestFramework.BeginScenario("PosTest1: Test whether GetEnumerator() is successful when the queue is not empty.");

        try
        {
            Queue<string> TestQueue = new Queue<string>();
            TestQueue.Enqueue("one");
            TestQueue.Enqueue("two");
            TestQueue.Enqueue("three");
            Queue<string>.Enumerator TestEnumerator;
            TestEnumerator = TestQueue.GetEnumerator();
            TestEnumerator.MoveNext();
            for (int i = 0; i < TestQueue.Count; i++)
            {
                if (TestQueue.ToArray()[i] != TestEnumerator.Current)
                {
                    TestLibrary.TestFramework.LogError("P01.1", "GetEnumerator() failed when the queue is not empty!");
                    retVal = false;
                }
                TestEnumerator.MoveNext();
            }

        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("P01.2", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogVerbose(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

    public bool PosTest1()
    {
        bool retVal = true;
        TestLibrary.TestFramework.BeginScenario("PosTest1: The enumerator should be positioned at the first element in the collection after MoveNext().");

        try
        {
            Queue<string> TestQueue = new Queue<string>();
            TestQueue.Enqueue("one");
            TestQueue.Enqueue("two");
            TestQueue.Enqueue("three");
            Queue<string>.Enumerator TestEnumerator;
            TestEnumerator = TestQueue.GetEnumerator();
            TestEnumerator.MoveNext();
            string TestString = TestEnumerator.Current;
            if (TestString != "one")
            {
                TestLibrary.TestFramework.LogError("P01.1", "The enumerator is not positioned at the first element in the collection after MoveNext()!");
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("P01.2", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogVerbose(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

    public bool PosTest1()
    {
        bool retVal = true;
        TestLibrary.TestFramework.BeginScenario("PosTest1: Resource of the Enumerator should be released after Dispose().");

        try
        {
            Queue<string> TestQueue = new Queue<string>();
            TestQueue.Enqueue("one");
            TestQueue.Enqueue("two");
            TestQueue.Enqueue("three");
            Queue<string>.Enumerator TestEnumerator;
            TestEnumerator = TestQueue.GetEnumerator();
            TestEnumerator.MoveNext();
            TestEnumerator.Dispose();
            string TestString = TestEnumerator.Current;
            TestLibrary.TestFramework.LogError("P01.1", "Resource of the Enumerator have not been released after Dispose()!");
            retVal = false;
        }
        catch (InvalidOperationException)
        {

        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("P01.2", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogVerbose(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

    public bool PosTest2()
    {
        bool retVal = true;
        TestLibrary.TestFramework.BeginScenario("PosTest2: Test whether GetEnumerator() is successful when the queue is empty.");

        try
        {
            Queue<string> TestQueue = new Queue<string>();
            Queue<string>.Enumerator TestEnumerator;
            TestEnumerator = TestQueue.GetEnumerator();
            try
            {
                string CurrentElement = TestEnumerator.Current;
                TestLibrary.TestFramework.LogError("P02.1", "GetEnumerator() failed when the queue is empty!");
                retVal = false;
            }
            catch (InvalidOperationException)
            {

            }
            bool b = TestEnumerator.MoveNext();
            if (b != false)
            {
                TestLibrary.TestFramework.LogError("P02.2", "GetEnumerator() failed when the queue is empty!");
                retVal = false;
            }
            try
            {
                string CurrentElement = TestEnumerator.Current;
                TestLibrary.TestFramework.LogError("P02.3", "GetEnumerator() failed when the queue is empty!");
                retVal = false;
            }
            catch (InvalidOperationException)
            {

            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("P02.4", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogVerbose(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

        public void Clear_Normal()
        {
            var q = new Queue<string>();
            Assert.Equal(0, q.Count);

            for (int repeat = 0; repeat < 2; repeat++) // repeat to ensure we can grow after emptying
            {
                // Add some elements
                for (int i = 0; i < 5; i++)
                {
                    q.Enqueue(i.ToString());
                }
                Assert.Equal(5, q.Count);
                Assert.True(q.GetEnumerator().MoveNext());

                // Clear them and make sure they're gone
                q.Clear();
                Assert.Equal(0, q.Count);
                Assert.False(q.GetEnumerator().MoveNext());
            }
        }

    public bool PosTest1()
    {
        bool retVal = true;
        TestLibrary.TestFramework.BeginScenario("PosTest1: Current() should be successful.");

        try
        {
            Queue<string> TestQueue = new Queue<string>();
            TestQueue.Enqueue("one");
            TestQueue.Enqueue("two");
            TestQueue.Enqueue("three");
            Queue<string>.Enumerator TestEnumerator = TestQueue.GetEnumerator();
            TestEnumerator.MoveNext();
            if (TestEnumerator.Current != "one")
            {
                TestLibrary.TestFramework.LogError("P01.1", "Current() failed!");
                retVal = false;
            }
            TestEnumerator.MoveNext();
            if (TestEnumerator.Current != "two")
            {
                TestLibrary.TestFramework.LogError("P01.2", "Current() failed!");
                retVal = false;
            }
            TestEnumerator.MoveNext();
            if (TestEnumerator.Current != "three")
            {
                TestLibrary.TestFramework.LogError("P01.3", "Current() failed!");
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("P01.4", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogVerbose(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

        static void Main(string[] args)
        {
            Queue<DateTime> aq = new Queue<DateTime>();
            aq.Enqueue(new DateTime(2008, 1, 19));   // item 1
            aq.Enqueue(new DateTime(2008, 4, 5));   // item 2
            aq.Enqueue(new DateTime(2008, 7, 2));   // item 3
            aq.Enqueue(new DateTime(2008, 12, 3));   // item 4

            Console.WriteLine("Count:    {0}", aq.Count);
            PrintValues(aq);

            // Peek item 1 but do not remove
            DateTime item = aq.Peek();
            Console.WriteLine("Peek: {0}", item.ToShortDateString());   // item is DateTime, not object
            PrintValues(aq);

            // Contains
            Boolean contains = aq.Contains(new DateTime(2008, 7, 2));
            Console.WriteLine("Contains: {0}", contains);

            // Remove items
            DateTime item1 = aq.Dequeue();
            DateTime item2 = aq.Dequeue();
            Console.WriteLine("Dequeue: {0}  {1}", item2.ToShortDateString(), item2.ToShortDateString());
            PrintValues(aq);
            Console.WriteLine("Count:    {0}", aq.Count);

            // Trim to size
            aq.TrimExcess();   // c.f. TrimToSize in non-generic Queue

            // iterate through Queue using a Queue.Enumerator
            Console.WriteLine("Listing using Queue.Enumerator");
            Queue<DateTime>.Enumerator qenum = aq.GetEnumerator();    // Queue<T>.Enumerator is a public inner struct declared in Queue<t>, see MyClass in this project for similar example
            while (qenum.MoveNext())
            {
                DateTime dt = qenum.Current;
                Console.WriteLine("{0}", dt.ToShortDateString());
            }
        }

    public bool PosTest3()
    {
        bool retVal = true;
        TestLibrary.TestFramework.BeginScenario("PosTest3: The enumerator should be positioned after the last element in the collection after MoveNext() passed the end of collection.");

        try
        {
            Queue<string> TestQueue = new Queue<string>();
            TestQueue.Enqueue("one");
            TestQueue.Enqueue("two");
            TestQueue.Enqueue("three");
            Queue<string>.Enumerator TestEnumerator;
            TestEnumerator = TestQueue.GetEnumerator();
            bool bSuc;
            bSuc = TestEnumerator.MoveNext();
            bSuc = TestEnumerator.MoveNext();
            bSuc = TestEnumerator.MoveNext();
            bSuc = TestEnumerator.MoveNext();
            bSuc = TestEnumerator.MoveNext();
            bSuc = TestEnumerator.MoveNext();
            if (bSuc)
            {
                TestLibrary.TestFramework.LogError("P03.1", "The enumerator is not positioned after the last element in the collection after MoveNext() passed the end of collection!");
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("P03.2", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogVerbose(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

    public bool NegTest2()
    {
        bool retVal = true;
        TestLibrary.TestFramework.BeginScenario("NegTest2: InvalidOperationException should be thrown when the enumerator is positioned after the last element of the collection.");

        try
        {
            Queue<string> TestQueue = new Queue<string>();
            TestQueue.Enqueue("one");
            TestQueue.Enqueue("two");
            TestQueue.Enqueue("three");
            Queue<string>.Enumerator TestEnumerator;
            TestEnumerator = TestQueue.GetEnumerator();
            TestEnumerator.MoveNext();
            TestEnumerator.MoveNext();
            TestEnumerator.MoveNext();
            TestEnumerator.MoveNext();
            string TestString = TestEnumerator.Current;
            TestLibrary.TestFramework.LogError("N02.1", "InvalidOperationException is not thrown when the enumerator is positioned after the last element of the collection!");
            retVal = false;
        }
        catch (InvalidOperationException)
        {

        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("N02.2", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogVerbose(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

    public bool NegTest3()
    {
        bool retVal = true;
        TestLibrary.TestFramework.BeginScenario("NegTest3: InvalidOperationException should be thrown when MoveNext after queue has been changed.");

        try
        {
            Queue<string> TestQueue = new Queue<string>();
            TestQueue.Enqueue("one");
            TestQueue.Enqueue("two");
            TestQueue.Enqueue("three");
            Queue<string>.Enumerator TestEnumerator = TestQueue.GetEnumerator();
            TestEnumerator.MoveNext();
            if (TestEnumerator.Current != "one")
            {
                TestLibrary.TestFramework.LogError("P02.1", "Current() failed!");
                retVal = false;
            }
            TestQueue.Dequeue();
            TestEnumerator.MoveNext();
            TestLibrary.TestFramework.LogError("P02.1", "InvalidOperationException not thrown when MoveNext after queue has been changed!");
            retVal = false;
        }
        catch (InvalidOperationException)
        {

        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("N03.2", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogVerbose(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

//.........这里部分代码省略.........
            LinkedList<int> l = new LinkedList<int>(arr);
            Test.IntLinkedListHelper.write(@out, l);
            byte[] data = @out.finished();
            @in = new Ice.InputStream(communicator, data);
            LinkedList<int> l2 = Test.IntLinkedListHelper.read(@in);
            test(Compare(l2, l));
        }

        {
            Test.MyEnum[] arr =
            {
                Test.MyEnum.enum3,
                Test.MyEnum.enum2,
                Test.MyEnum.enum1,
                Test.MyEnum.enum2
            };
            @out = new Ice.OutputStream(communicator);
            LinkedList<Test.MyEnum> l = new LinkedList<Test.MyEnum>(arr);
            Test.MyEnumLinkedListHelper.write(@out, l);
            byte[] data = @out.finished();
            @in = new Ice.InputStream(communicator, data);
            LinkedList<Test.MyEnum> l2 = Test.MyEnumLinkedListHelper.read(@in);
            test(Compare(l2, l));
        }

        {
            @out = new Ice.OutputStream(communicator);
            LinkedList<Test.SmallStruct> l = new LinkedList<Test.SmallStruct>(smallStructArray);
            Test.SmallStructLinkedListHelper.write(@out, l);
            byte[] data = @out.finished();
            @in = new Ice.InputStream(communicator, data);
            LinkedList<Test.SmallStruct> l2 = Test.SmallStructLinkedListHelper.read(@in);
            test(l2.Count == l.Count);
            IEnumerator<Test.SmallStruct> e = l.GetEnumerator();
            IEnumerator<Test.SmallStruct> e2 = l2.GetEnumerator();
            while (e.MoveNext() && e2.MoveNext())
            {
                test(e.Current.Equals(e2.Current));
            }
        }

        {
            long[] arr =
            {
                0x01,
                0x11,
                0x12,
                0x22
            };
            @out = new Ice.OutputStream(communicator);
            Stack<long> l = new Stack<long>(arr);
            Test.LongStackHelper.write(@out, l);
            byte[] data = @out.finished();
            @in = new Ice.InputStream(communicator, data);
            Stack<long> l2 = Test.LongStackHelper.read(@in);
            test(Compare(l2, l));
        }

        {
            float[] arr =
            {
                (float)1,
                (float)2,
                (float)3,
                (float)4
            };

 public void Clear_Wrapped()
 {
     // Try to exercise special case of clearing when we've wrapped around
     var q = new Queue<string>(4);
     for (int i = 0; i < 4; i++)
     {
         q.Enqueue(i.ToString());
     }
     Assert.Equal("0", q.Dequeue());
     Assert.Equal("1", q.Dequeue());
     q.Enqueue("5");
     q.Enqueue("6");
     Assert.Equal(4, q.Count);
     q.Clear();
     Assert.Equal(0, q.Count);
     Assert.False(q.GetEnumerator().MoveNext());
 }

        public void Rollback()
        {
            if (transactedEntries != null && transactedEntries.Count > 0)
            {
                // make a list of non-transacted entries
                // @undone: bmalhi: transacted entries only on priority-0

                IEnumerator<SchedulableItem> e = this.normalPriorityEntriesQueue.GetEnumerator();
                Queue<SchedulableItem> newScheduled = new Queue<SchedulableItem>();
                while (e.MoveNext())
                {
                    if (!transactedEntries.Contains(e.Current))
                        newScheduled.Enqueue(e.Current);
                }

                // clear the scheduled items
                this.normalPriorityEntriesQueue.Clear();

                // schedule the non-transacted items back
                e = newScheduled.GetEnumerator();
                while (e.MoveNext())
                    this.normalPriorityEntriesQueue.Enqueue(e.Current);

                transactedEntries = null;
            }
        }

    public bool NegTest1()
    {
        bool retVal = true;
        TestLibrary.TestFramework.BeginScenario("NegTest1: InvalidOperationException should be thrown when the collection was modified after the enumerator was created.");

        try
        {
            Queue<string> TestQueue = new Queue<string>();
            TestQueue.Enqueue("one");
            TestQueue.Enqueue("two");
            TestQueue.Enqueue("three");
            Queue<string>.Enumerator TestEnumerator;
            TestEnumerator = TestQueue.GetEnumerator();
            TestQueue.Enqueue("four");
            TestEnumerator.MoveNext();
            TestLibrary.TestFramework.LogError("N01.1", "InvalidOperationException is not thrown when the collection was modified after the enumerator was created!");
            retVal = false;
        }
        catch (InvalidOperationException)
        {

        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("N01.2", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogVerbose(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

    public bool PosTest4()
    {
        bool retVal = true;
        TestLibrary.TestFramework.BeginScenario("PosTest4: With a Queue that contains three items, MoveNext returns true the first three times and returns false every time it is called after that.");

        try
        {
            bool b;
            Queue<string> TestQueue = new Queue<string>();
            TestQueue.Enqueue("one");
            TestQueue.Enqueue("two");
            TestQueue.Enqueue("three");
            Queue<string>.Enumerator TestEnumerator;
            TestEnumerator = TestQueue.GetEnumerator();
            for (int i = 0; i < 3; i++)
            {
                b = TestEnumerator.MoveNext();
                if (!b)
                {
                    TestLibrary.TestFramework.LogError("P04.1", "MoveNext() failed!");
                    retVal = false;
                }
            }
            b = TestEnumerator.MoveNext();
            if (b)
            {
                TestLibrary.TestFramework.LogError("P04.1", "MoveNext() failed!");
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("P04.2", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogVerbose(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }