C#中双向链表的扩展性设计

在C#中，双向链表是一种数据结构，它包含两个指针，一个指向前一个节点，另一个指向后一个节点。为了实现一个具有扩展性的双向链表，我们可以使用泛型和接口。这样，我们可以轻松地为不同的数据类型和场景创建自定义的双向链表。

首先，我们需要创建一个表示链表节点的类：

public class DoublyLinkedListNode<T>
{
    public T Value { get; set; }
    public DoublyLinkedListNode<T> Previous { get; set; }
    public DoublyLinkedListNode<T> Next { get; set; }

    public DoublyLinkedListNode(T value)
    {
        Value = value;
    }
}

接下来，我们需要创建一个表示双向链表的接口：

public interface IDoublyLinkedList<T>
{
    void AddFirst(T value);
    void AddLast(T value);
    bool Remove(T value);
    bool Contains(T value);
    int Count { get; }
}

现在，我们可以实现这个接口，创建一个具体的双向链表类：

public class DoublyLinkedList<T> : IDoublyLinkedList<T>
{
    private DoublyLinkedListNode<T> _head;
    private DoublyLinkedListNode<T> _tail;
    private int _count;

    public int Count => _count;

    public void AddFirst(T value)
    {
        var newNode = new DoublyLinkedListNode<T>(value);
        if (_head == null)
        {
            _head = newNode;
            _tail = newNode;
        }
        else
        {
            newNode.Next = _head;
            _head.Previous = newNode;
            _head = newNode;
        }
        _count++;
    }

    public void AddLast(T value)
    {
        var newNode = new DoublyLinkedListNode<T>(value);
        if (_tail == null)
        {
            _head = newNode;
            _tail = newNode;
        }
        else
        {
            newNode.Previous = _tail;
            _tail.Next = newNode;
            _tail = newNode;
        }
        _count++;
    }

    public bool Remove(T value)
    {
        var currentNode = _head;
        while (currentNode != null)
        {
            if (currentNode.Value.Equals(value))
            {
                if (currentNode.Previous != null)
                {
                    currentNode.Previous.Next = currentNode.Next;
                }
                else
                {
                    _head = currentNode.Next;
                }

                if (currentNode.Next != null)
                {
                    currentNode.Next.Previous = currentNode.Previous;
                }
                else
                {
                    _tail = currentNode.Previous;
                }

                _count--;
                return true;
            }
            currentNode = currentNode.Next;
        }
        return false;
    }

    public bool Contains(T value)
    {
        var currentNode = _head;
        while (currentNode != null)
        {
            if (currentNode.Value.Equals(value))
            {
                return true;
            }
            currentNode = currentNode.Next;
        }
        return false;
    }
}

现在，我们已经创建了一个具有扩展性的双向链表实现。你可以根据需要为不同的数据类型和场景创建自定义的双向链表。例如，你可以为整数、字符串或自定义对象创建双向链表。