LRU cache leetcode

public class LRUCache
{
    public readonly int _capacity;

    private int _count = 0;

    private readonly Dictionary<int, OurNode> _keyToLinkToNode;
    private readonly OurLinkedList _queue = new();

    public LRUCache(int capacity)
    {
        _capacity = capacity;
        _keyToLinkToNode = new(_capacity + 1);
    }

    public int Get(int key)
    {
        if (!_keyToLinkToNode.TryGetValue(key, out OurNode? neededNode))
        {
            return -1;
        }

        var getValue = neededNode.Value.Value;

        _queue.ReplaceToEnd(neededNode);

        return getValue;
    }

    public void Put(int key, int value)
    {
        if (_keyToLinkToNode.TryGetValue(key, out OurNode existingNode))
        {
            existingNode.Value = KeyValuePair.Create(key, value);
            _queue.ReplaceToEnd(existingNode);
        }
        else
        {
            if (_capacity != _count)
            {
                _count++;
            }
            else
            {
                var nodeToDelete = _queue.First;
                _keyToLinkToNode.Remove(nodeToDelete.Value.Key);
                _queue.RemoveFirst();
            }

            _queue.AddLast(KeyValuePair.Create(key, value));
            var addedNode = _queue.Last;
            _keyToLinkToNode[key] = addedNode;
        }
    }
}

internal class OurLinkedList
{
    public OurNode First;
    public OurNode Last;

    public void ReplaceToEnd(OurNode node)
    {
        if (Last == node)
        {
            return;
        }
        else if (First == node)
        {
            First = First.Next;
            First.Previous = null!;

            node.Previous = Last;
            node.Next = null!;

            Last.Next = node;
            Last = node;
        }
        else
        {
            node.Previous.Next = node.Next;
            node.Next.Previous = node.Previous;

            node.Previous = Last;
            node.Next = null!;

            Last.Next = node;
            Last = node;
        }
    }

    public void RemoveFirst()
    {
        if (First == Last)
        {
            First = null!;
            Last = null!;
        }
        else
        {
            First = First.Next;
            First.Previous = null!;
        }
    }

    public void AddLast(KeyValuePair value)
    {
        OurNode newNode = new(value);

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

internal class OurNode
{
    public KeyValuePair Value { get; set; }
    public OurNode Previous { get; set; }
    public OurNode Next { get; set; }

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

internal struct KeyValuePair
{
    public int Key;
    public int Value;

    public KeyValuePair(int key, int value)
    {
        Key = key;
        Value = value;
    }

    public static KeyValuePair Create(int key, int value) => new(key, value);
}