Managing Hospital Data with C# and Doubly Linked Circular Lists: Issue with Patient Information Output Display

As it is the code does not compile. If you remove the extra backslashes it will work. E.g. Node<T>? instead of Node\<T\>? and string[] instead of string\[\].

Btw.: Circular lists make no sense for this kind of data. There is nothing circular about patients and doctors.

The implementation can be improved. There should be no need to have Previous and Next properties in the data classes. These should only be in the Node<T> class. The nodes should have a Data property instead of a ID property:

public class Node<T>
{
    public required T Data { get; set; }
    public Node<T>? Previous { get; set; }
    public Node<T>? Next { get; set; }
}

Adding some required modifiers to the properties removes null warnings. The ID properties must not be nullable.

public class Patient
{
    public required long ID { get; set; }
    public required string FirstName { get; set; }
    public required string LastName { get; set; }

    public override string ToString() => $"{ID}. {FirstName} {LastName}";
}

public class Medicine
{
    public required long ID { get; set; }
    public required string Name { get; set; }

    public override string ToString() => $"{ID}. {Name}";
}

public class Doctor
{
    public required long ID { get; set; }
    public required string Name { get; set; }
    public required string Specialty { get; set; }

    public override string ToString() => $"{ID}. {Name} ({Specialty})";
}

public class Disease
{
    public required long ID { get; set; }
    public required string Name { get; set; }

    public override string ToString() => $"{ID}. {Name}";
}

Adding the comments like // Medicine class to class Medicine adds no value. Comments should add information missing in the code. E.g. design decisions and other non obvious facts.

public class DoublyLinkedCircularList<T>
{
    private Node<T>? _head;

    public void Add(T element)
    {
        var newNode = new Node<T> { Data = element };
        if (_head == null) {
            _head = newNode;
            _head.Previous = _head;
            _head.Next = _head;
        } else {
            newNode.Previous = _head.Previous;
            newNode.Next = _head;
            _head.Previous!.Next = newNode;
            _head.Previous = newNode;
        }
    }

    public T? QueryById(Func<T, bool> query)
    {
        if (_head == null) {
            return default;
        }

        Node<T>? current = _head;
        do {
            if (query(current!.Data)) {
                return current.Data;
            }
            current = current.Next;
        } while (current != _head);

        return default;
    }
}

By using primary constructors and getter-only properties we can simplify the classes:

public class Patient(long id, string firstName, string lastName)
{
    public long ID { get; } = id;
    public string FirstName { get; } = firstName;
    public string LastName { get; } = lastName;

    public override string ToString() => $"{ID}. {FirstName} {LastName}";
}

The patients are now initialized like this:

patientList.Add(new Patient(46573806740, "Hiranur", "Sazak"));
patientList.Add(new Patient(23746982347, "Nisa Nur", "Özdal"));
patientList.Add(new Patient(89374938243, "Nisa Gül", "Ünal"));
patientList.Add(new Patient(98723424674, "Berfin", "Geleş"));

Since patientList.Add requires a Patient argument, C# can infer the type Patient and we can write:

patientList.Add(new(46573806740, "Hiranur", "Sazak"));
patientList.Add(new(23746982347, "Nisa Nur", "Özdal"));
patientList.Add(new(89374938243, "Nisa Gül", "Ünal"));
patientList.Add(new(98723424674, "Berfin", "Geleş"));

Circular lists are rarely useful. Therefore lets implement a non circular linked list. Since we never move backwards through the list, the Previous link is not required and the list does not need to be doubly linked.

The node class is never exposed publicly. Therefore, we can implement it as nested private class. To enable adding elements to the end of the list we also add a reference to the _tail node.

public class LinkedList<T> : IEnumerable<T>
{
    private class Node
    {
        public required T Data { get; set; }
        public Node? Next { get; set; }
        public override string ToString() => $"Data = [{Data}]";
    }

    private Node? _head, _tail;

    public void Add(T element)
    {
        var newNode = new Node { Data = element };
        if (_head == null) {
            _head = newNode;
            _tail = newNode;
        } else {
            _tail!.Next = newNode;
            _tail = newNode;
        }
    }

    ...
}

Note the : IEnumerable<T> in the class header. It means that the class must implement the IEnumerable<T> interface which is very useful. It enables us to use foreach to loop through the list and gives us access to a lot of IEnumerable<T> extension methods that are part of the Language INtegrated Query LINQ.

Only one method needs to be implemented:

IEnumerator<T> GetEnumerator()

However, we must return an object which implements the IEnumerator<T> Interface. We implement it as nested private struct LinkedListEnumerator. To do this we replace the 3 dots (...) above with:

private struct LinkedListEnumerator(LinkedList<T> linkedList) : IEnumerator<T>
{
    // Enumerators are positioned before the first element until the first MoveNext() call.
    private Node? _currentNode = new() { Data = default!, Next = linkedList._head };

    public readonly T Current => _currentNode is null ? default! : _currentNode.Data;

    readonly object IEnumerator.Current => Current!;

    public readonly void Dispose() { }

    public bool MoveNext()
    {
        _currentNode = _currentNode?.Next;
        return _currentNode != null;
    }

    public void Reset()
    {
        _currentNode = new() { Data = default!, Next = linkedList._head };
    }
}

public IEnumerator<T> GetEnumerator() => new LinkedListEnumerator(this);

IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

Now we can initialize the patients list by using a collection initializer:

var patientList = new LinkedList<Patient>{
    new(46573806740, "Hiranur", "Sazak"),
    new(23746982347, "Nisa Nur", "Özdal"),
    new(89374938243, "Nisa Gül", "Ünal"),
    new(98723424674, "Berfin", "Geleş")
};

We can loop through the patients like this:

foreach (Patient patient in patientList) {
    Console.WriteLine(patient);
}

And we can find a patient like this by using LINQ (you may need to add using System.Linq; at the top of your code):

Patient? queriedPatient = patientList.FirstOrDefault(patient => patient.ID == ID);

Note that we did not have to implement QueryById as LINQ implements it with the extension method FirstOrDefault. LINQ uses our IEnumerable<T> implementation to iterate the list.

Another useful interface that we could implement (not shown here) is the ICollection<T> Interface. It is implemented by a lot of collections and lets us easily replace one collection by another.