Односвязный кольцевой список [code review]

/*
    Операции:
    - Поиск элемента по индексу
    - Вставка в начало/конец
    - Вставка перед/после элемента x
    - Удаление первого/последнего элемента
    - Удаление элемента перед/после x
    - Удаление целевого элемента
*/
 
using System;
 
namespace Examples.Collections.Generic
{
    //Односвязный кольцевой список.
    public class CycledLinkedList<T> : IPrintable
    {
        #region PrivateSection
        private void TryThrowInvalidOperationException()
        {
            if (Count == 0)
            {
                throw new InvalidOperationException("Односвязный кольцевой список пуст");
            }
        }
 
        private void TryThrowArgumentException(Node<T> target)
        {
            if (target == Head)
            {
                throw new ArgumentException(Helper.InvalidTarget);
            }
        }
 
        private bool FindHelper(int count, Node<T> node, T value)
        {
            return ((count < 2) && !node.Value.Equals(value));
        }
 
        private Node<T> Find(T value)
        {
            int count = 0;
            Node<T> current = Head;
            while (FindHelper(count, current, value))
            {
                if (current == Head)
                {
                    count++;
                }
                current = current.Next;
            }
            if (count == 2)
            {
                TryThrowArgumentException(Head);
            }
            return current;
        }
 
        private void Move(ref Node<T> first, ref Node<T> second)
        {
            first = second;
            second = second.Next;
        }
 
        private Node<T> FindPrevious(T value)
        {
            int count = 0;
            Node<T> previous = Tail;
            Node<T> current = Head;
            while (FindHelper(count, current, value))
            {
                if (current == Head)
                {
                    count++;
                }
                Move(ref previous, ref current);
            }
            if (count == 2)
            {
                TryThrowArgumentException(Head);
            }
            return previous;
        }
 
        private void AddAfter(Node<T> target, T value)
        {
            Node<T> node = new Node<T>(value, target.Next);
            target.Next = node;
        }
        #endregion PrivateSection
 
        #region PublicSection
        #region PublicSection.Properties.Owner
        public Node<T> Head { get; private set; }
        public Node<T> Tail { get; private set; }
        public int Count { get; private set; }
        #endregion PublicSection.Properties.Owner
 
        #region PublicSection.Methods
        #region PublicSection.Methods.InterfaceImplementations.IPrintable
        public void Print() => Console.Write(ToString());
 
        public void Println() => Console.WriteLine(ToString());
        #endregion PublicSection.Methods.InterfaceImplementations.IPrintable
 
        #region PublicSection.Methods.UserOperations
        public void AddFirst(T value)
        {
            Node<T> node = new Node<T>(value, Head);
            if (Count == 0)
            {
                Tail = node;
            }
            Head = node;
            Tail.Next = node;
            Count++;
        }
 
        public void AddLast(T value)
        {
            Node<T> node = new Node<T>(value, Head);
            if (Count == 0)
            {
                Head = node;
                Head.Next = node;
            }
            else
            {
                Tail.Next = node;
            }
            Tail = node;
            Count++;
        }
 
        public void AddBefore(T target, T value)
        {
            Node<T> previous = FindPrevious(target);
            AddAfter(previous, value);
            if (previous.Next.Next == Head)
            {
                Head = previous.Next;
            }
            Count++;
        }
 
        public void AddAfter(T target, T value)
        {
            Node<T> current = Find(target);
            AddAfter(current, value);
            if (current == Tail)
            {
                Tail = current.Next;
            }
            Count++;
        }
 
        public void RemoveFirst()
        {
            TryThrowInvalidOperationException();
            if (Count == 1)
            {
                Clear();
            }
            else
            {
                Head = Head.Next;
                Tail.Next = Head;
                Count--;
            }
        }
 
        public void RemoveLast()
        {
            TryThrowInvalidOperationException();
            if (Count == 1)
            {
                Clear();
            }
            else
            {
                Node<T> previous = Head.Next;
                while (previous.Next != Tail)
                {
                    previous = previous.Next;
                }
                previous.Next = Head;
                Tail = previous;
                Count--;
            }
        }
 
        public void RemoveBefore(T value)
        {
            TryThrowInvalidOperationException();
            if (Count < 2)
            {
                TryThrowArgumentException(Head);
            }
            Node<T> previous = Tail;
            while ((previous.Next.Next != Head) && !previous.Next.Next.Value.Equals(value))
            {
                previous = previous.Next;
            }
            TryThrowArgumentException(previous.Next.Next);
            if (previous.Next == Head)
            {
                Head = previous.Next.Next;
            }
            previous.Next = previous.Next.Next;
            Count--;
        }
 
        public void RemoveAt(T value)
        {
            TryThrowInvalidOperationException();
            if ((Count == 1) && Head.Value.Equals(value))
            {
                Clear();
            }
            else
            {
                Node<T> previous = FindPrevious(value);
                if (previous.Next == Head)
                {
                    Head = previous.Next.Next;
                }
                else if (previous.Next == Tail)
                {
                    Tail = previous;
                }
                previous.Next = previous.Next.Next;
                Count--;
            }
        }
 
        public void RemoveAfter(T value)
        {
            TryThrowInvalidOperationException();
            Node<T> previous = Find(value);
            TryThrowArgumentException(previous.Next);
            if (previous.Next == Tail)
            {
                Tail = previous;
            }
            previous.Next = previous.Next.Next;
            Count--;
        }
 
        public void Clear()
        {
            Head = null;
            Tail = null;
            Count = 0;
        }
 
        public override string ToString()
        {
            Node<T> current = Head;
            string result = $"CycledLinkedList[{typeof(CycledLinkedList<T>).GetGenericArguments()[0]}]: [";
            do
            {
                result += current + (current.Next != Head ? Helper.Delimiter : "");
                current = current.Next;
            }
            while (current != Head);
            result += ']';
            return result;
        }
        #endregion PublicSection.Methods.UserOperations
        #endregion PublicSection.Methods
        #endregion PublicSection
    }
}

namespace Examples
{
    public interface IPrintable
    {
        void Print();
        void Println();
    }
}

using Examples.Collections.Generic;
 
namespace Examples
{
    //Вспомогательный класс.
    public static class Helper
    {
        #region PublicSection.Constants.Owner
        public const string Delimiter = ", ";
        public const int MaxSize = 32;
        public const string InvalidTarget = "Опорный узел, требуемый для выполнения данной операции не найден";
        #endregion PublicSection.Constants.Owner
 
        #region PublicSection.Methods.UserOperations
        public static void Swap<T>(ref T x, ref T y)
        {
            var z = x;
            x = y;
            y = z;
        }
 
        public static string ToString<T>(T[] target, int count)
        {
            string result = "[";
            for(var i = 0; i < count; i++)
            {
                result += target[i] + (i + 1 < count ? Delimiter : "");
            }
            result += ']';
            return result;
        }
 
        public static string ToString<T>(Node<T> head)
        {
            Node<T> current = head;
            string result = "[";
            while (current != null)
            {
                result += current + (current.Next != null ? Delimiter : "");
                current = current.Next;
            }
            result += ']';
            return result;
        }
 
        public static string ToString<T>(Node2<T> head)
        {
            Node2<T> current = head;
            string result = "[";
            while (current != null)
            {
                result += current + (current.Next != null ? Delimiter : "");
                current = current.Next;
            }
            result += ']';
            return result;
        }
        #endregion PublicSection.Methods.UserOperations
    }
}

using System;
 
namespace Examples
{
    public interface ICloneableAs<T> : ICloneable
    {
        T CloneAs();
    }
}

if ((divisor != 0) && (dividend / divisor > 0))
{
    Console.WriteLine("Quotient: {0}", dividend / divisor);
}
else
{
    Console.WriteLine("Attempted division by 0 ends up here.");
}

foreach (var ch in laugh)
{
    if (ch == 'h')
        Console.Write("H");
    else
        Console.Write(ch);
}
Console.WriteLine();