Linked List in C#

I was searching for a implementation of a Linked List with the same power as a native List.

I wanted functionality closer to a List. The System.Collections.Generic.LinkedList misses some methods I'm used to work with, like Add Sort or access by index mylist[0]

I didn't find one so I made one of my own:

• I added the same constructors as List

• I used a merge sort which should be the most performant for this case

• I added IEnumberable to be able to use the power of Linq

• I added all native methods of a List

I'm searching for mistakes, performance improvements or missing functionality.

Note: This is not about a circular or doubly linked list; it's just about a singly linked list.

```
public class Node
{
public T data;
public Node next;
}

public class MyLinkedList : IEnumerable, System.Collections.IEnumerable
{
private Node _headNode;
private int _count;
public int Count { get { { return _count; } } }

private IEnumerable> Nodes
{
get
{
Node node = _headNode;
while (node != null)
{
yield return node;
node = node.next;
}
}
}

private Node Pop()
{
Node tResult = null;
if (_headNode != null)
{
tResult = _headNode;
_headNode = _headNode.next;
_count--;
}
return tResult;
}

private void Push(Node item)
{
item.next = _headNode;
_headNode = item;
_count++;
}

private Node NodeAt(int index)
{
if (index _count)
{
throw new IndexOutOfRangeException("Index");
}
int counter = 0;
foreach (Node item in Nodes)
{
if (counter == index)
{
return item;
}
counter++;
}
return null;
}

public MyLinkedList()
{
_headNode = null;
_cou

Just a few quick remarks:

• Creating a linked list from another enumerable stores items in reverse order. That's probably not what most people would expect. Note that System.Collections.Generic.LinkedList does preserve the original order.

• A similar case can be made for Add: it adds items to the front. People familiar with List would expect it to add at the end. Note that LinkedList explicitly uses AddFirst and AddLast, likely to prevent such confusion. Granted, not all collections are ordered, but if you do want to stick to this behavior, then at least document it.

• Implement ICollection() and IList() while you're at it. You already implemented most of their functionality anyway (sometimes with different method names, or methods with different argument order).

• Keeping track of the tail node allows you to improve the performance of adding items at the end (at the expense of making removing and inserting nodes a bit more complicated).

• There are several methods that don't really need to be member methods, such as Find, Distinct and Reverse. Linq already provides extension methods for these (using mostly the same names, except that Find is called Where).

• The same can be said for ForEach: it can easily be implemented as an extension method, which would make it available for everything that implements IEnumerable(). Or you could just use foreach.

• Some methods appear to be unused, such as Pop and Push.

StackExchange Code Review Q#138142, answer score: 22