LRU Cache C#

public class LRUCache
{
    public int Capacity { get; set; }

    public int _count = 0;
    public int Count => _count;

    private Dictionary<int, OurNode<(int, int)>> KeyAndLinkToNode { get; set; } = [];
    private OurLinkedList<(int, int)> Queue { get; set; } = new();

    public LRUCache(int capacity)
    {
        Capacity = capacity;
    }

    public int Get(int key)
    {
        if (!KeyAndLinkToNode.TryGetValue(key, out var nodeWithValue))
        {
            return -1;
        }
        var finalValue = nodeWithValue.Value.Item2;


        if (Count == 0)
            throw new InvalidOperationException("ЧЛЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕН");
        else if (Count == 1)
        {

        }
        else if (nodeWithValue.Previous is null)
        {
            Queue.First = Queue.First.Next;
            Queue.Last.Next = nodeWithValue;
            Queue.Last = nodeWithValue;
        }
        else if (nodeWithValue.Next is null)
        {

        }
        else
        {
            nodeWithValue.Previous.Next = nodeWithValue.Next;
            Queue.Last.Next = nodeWithValue;
        }



        Console.WriteLine(finalValue);
        return finalValue;
    }

    public void Put(int key, int value)
    {
        if (KeyAndLinkToNode.ContainsKey(key))
        {
            var nodeToUpdate = KeyAndLinkToNode[key];
            nodeToUpdate.Value = (nodeToUpdate.Value.Item1, value);

            if (Count == 0)
                throw new InvalidOperationException("ЧЛЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕН");
            else if (Count == 1)
            {

            }
            else if (nodeToUpdate.Previous is null)
            {
                Queue.First = Queue.First.Next;
                Queue.Last.Next = nodeToUpdate;
                Queue.Last = nodeToUpdate;
            }
            else if (nodeToUpdate.Next is null)
            {

            }
            else
            {
                nodeToUpdate.Previous.Next = nodeToUpdate.Next;
                Queue.Last.Next = nodeToUpdate;
            }

            return;
        }

        if (Count == Capacity)
        {
            var deletedNode = Queue.First;
            Queue.RemoveFirst();

            KeyAndLinkToNode.Remove(deletedNode!.Value.Item1);
            _count -= 1;
        }

        Queue.AddLast((key, value));
        var node = Queue.Last;
        KeyAndLinkToNode[key] = node;
        _count += 1;
    }

    public class OurLinkedList<T>
    {
        private int _count;

        public OurNode<T> First { get; set; }
        public OurNode<T> Last { get; set; }
        public int Count => _count;

        // Добавление элемента в начало списка
        public void AddFirst(T value)
        {
            OurNode<T> newNode = new OurNode<T>(value);

            if (First == null)
            {
                First = newNode;
                Last = newNode;
            }
            else
            {
                newNode.Next = First;
                First.Previous = newNode;
                First = newNode;
            }

            _count++;
        }

        // Удаление первого элемента списка
        public void RemoveFirst()
        {
            if (First == null)
                throw new InvalidOperationException("The list is empty.");

            if (First == Last)
            {
                First = null;
                Last = null;
            }
            else
            {
                First = First.Next;
                First.Previous = null;
            }

            _count--;
        }

        // Добавление элемента в конец списка
        public void AddLast(T value)
        {
            OurNode<T> newNode = new OurNode<T>(value);

            if (Last == null)
            {
                First = newNode;
                Last = newNode;
            }
            else
            {
                newNode.Previous = Last;
                Last.Next = newNode;
                Last = newNode;
            }

            _count++;
        }

        // Удаление последнего элемента списка
        public void RemoveLast()
        {
            if (Last == null)
                throw new InvalidOperationException("The list is empty.");

            if (First == Last)
            {
                First = null;
                Last = null;
            }
            else
            {
                Last = Last.Previous;
                Last.Next = null;
            }

            _count--;
        }
    }

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

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