将IEnumerator/IEnumerable实现到自定义队列类中，而不是使用队列

将IEnumerator/IEnumerable实现到自定义队列类中，而不是使用队列，意味着我们要自己实现一个队列数据结构，并且使其能够支持迭代操作。

队列是一种先进先出（FIFO）的数据结构，常用于处理需要按照顺序进行的任务或数据。在C#中，可以使用Queue<T>类来实现队列功能。但是，如果我们想要自定义队列类，并且希望能够使用foreach语句对其进行迭代，就需要实现IEnumerator和IEnumerable接口。

首先，我们需要定义一个自定义队列类，该类应该包含以下基本功能：

入队（Enqueue）：将元素添加到队列的末尾。
出队（Dequeue）：从队列的头部移除并返回元素。
判断队列是否为空（IsEmpty）：检查队列是否为空。
获取队列的大小（Size）：返回队列中元素的数量。

接下来，我们需要实现IEnumerator接口，该接口定义了用于在集合中进行迭代的方法和属性。我们需要实现以下方法：

MoveNext：将迭代器移动到集合的下一个元素，并返回一个布尔值，指示是否成功移动到下一个元素。
Reset：将迭代器重置到集合的开头。
Current：获取集合中当前位置的元素。

然后，我们还需要实现IEnumerable接口，该接口定义了一个方法，该方法返回一个IEnumerator对象，用于在集合上进行迭代。

下面是一个示例代码，演示了如何将IEnumerator/IEnumerable实现到自定义队列类中：

using System;
using System.Collections;

public class CustomQueue<T> : IEnumerable
{
    private T[] items;
    private int front;
    private int rear;

    public CustomQueue()
    {
        items = new T[10];
        front = 0;
        rear = -1;
    }

    public void Enqueue(T item)
    {
        if (rear == items.Length - 1)
        {
            Array.Resize(ref items, items.Length * 2);
        }
        items[++rear] = item;
    }

    public T Dequeue()
    {
        if (IsEmpty())
        {
            throw new InvalidOperationException("Queue is empty");
        }
        T item = items[front++];
        if (front == rear + 1)
        {
            front = 0;
            rear = -1;
        }
        return item;
    }

    public bool IsEmpty()
    {
        return front == rear + 1;
    }

    public int Size()
    {
        return rear - front + 1;
    }

    public IEnumerator GetEnumerator()
    {
        return new CustomQueueEnumerator<T>(items, front, rear);
    }
}

public class CustomQueueEnumerator<T> : IEnumerator
{
    private T[] items;
    private int front;
    private int rear;
    private int current;

    public CustomQueueEnumerator(T[] items, int front, int rear)
    {
        this.items = items;
        this.front = front;
        this.rear = rear;
        current = front - 1;
    }

    public bool MoveNext()
    {
        if (current < rear)
        {
            current++;
            return true;
        }
        return false;
    }

    public void Reset()
    {
        current = front - 1;
    }

    public object Current
    {
        get { return items[current]; }
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        CustomQueue<int> queue = new CustomQueue<int>();
        queue.Enqueue(1);
        queue.Enqueue(2);
        queue.Enqueue(3);

        foreach (int item in queue)
        {
            Console.WriteLine(item);
        }
    }
}

在上面的示例代码中，我们定义了一个CustomQueue<T>类，实现了入队、出队、判断队列是否为空和获取队列大小的功能。然后，我们实现了CustomQueueEnumerator<T>类，用于在队列上进行迭代。最后，在Main方法中，我们使用foreach语句对自定义队列进行迭代，并输出队列中的元素。

这样，我们就成功地将IEnumerator/IEnumerable实现到自定义队列类中，使其能够支持迭代操作。

推荐的腾讯云相关产品和产品介绍链接地址：