Yep, adding is a simple two-steps loop with CAS on the previous .Next pointer; but removing is hard!
Actually you can't do it without using an additional piece of information and logic.
Harris created the solution to this problem by adding a marker bit that once set disallows anyone to modify the node. The removal becomes two-steps: first (CAS) mark the removed node to prevent anyone from changing it (especially its .Next pointer); second CAS the previous node .Next pointer, which is now safe because the other node has been marked.
The problem is now that in C Harris used the two least significant bits of the .Next pointer as marker. This is clever because with 4-bytes aligned pointers they are always unused (i.e. 00) and because they fit in the 32 bits pointer they can be CAS atomically with the pointer itself, which is key to this algorithm. Of course this is impossible in C#, at least without using unsafe code.
The solution gets a little more complicated and involves an additional reference to an immutable class containg the two fields (.Next + marker).
Instead of going into a lengthy explanation of those ideas, I have found some references on the internet that will go into all the details that you need, see:
Lock-free Linked List (Part 1) Explains the problem;
Lock-free Linked List (Part 2) Explains the C solution + the spinlock solution;
Lock-free Linked List (Part 3) Explains the immutable state reference;
If you are really curious about the topic there are academic papers with various solutions and analysis of their performance, e.g. this one: Lock-free linked lists and skip lists