Создать класс обобщённый однонаправленный список

public class List1<T>
    {        
        List<int> list = new List<int>();
        public List1(List<int> list)
        {
            this.list = list;
        }
 
        ~List1()
        {
 
        }
 
        public static List1<T> operator +(List1<T> a, List1<T> b)
        {
            a.list.Union(b.list);
            return new List1<T>(a.list);
        }
        public static List1<T> operator -(List1<T> a, int index)
        {
            a.list.Remove(index);
            return new List1<T>(a.list);
        }
              
       public static bool operator ==( List1<T> a1, List1<T> a2)
        {
            return a1.list.SequenceEqual(a2.list);
        }
 
        public static  bool operator !=(List1<T> a1, List1<T> a2)
        {
            return !a1.list.SequenceEqual(a2.list);
        }
 
        public static bool operator ~(List1<T> a)
        {
            return a.list.Any();
        }
      
        public void Print()
        {
            foreach (var u in list)
            {
                Console.Write(u + " ");
            }
            Console.WriteLine();
        }
    }
 
    class Program
    {
        static void Main(string[] args)
        {
                                
        }
    }

static void Main(string[] args)
        {
            List1 <int> list1 = new List1 <int>(new List<int> {1,2,3,4,5,6,7,8});
            List1<int> list2 = new List1<int>(new List<int> { 1, 2, 3, 4, 5 });
            List1<int> list3 = list1 + list2;
            list3 = list3 - 2;
            Console.WriteLine(list3 == list2);
            Console.WriteLine(list3 != list2);
            List1<int> list4 = new List1<int>(new List<int> {});
            Console.WriteLine(~list4);
            list3.Print();
        }

        public static List1<T> operator +(List1<T> a, List1<T> b)
        {
            a.list.Union(b.list);
            return new List1<T>(a.list);
        }

        public static List1<T> operator +(List1<T> a, List1<T> b)
        {
            var t = a.list.Union(b.list).ToList();
            return new List1<T>(t);
        }

    /// <summary>Базовый класс односвязного списка</summary>
    /// <typeparam name="T">Тип элемента списка</typeparam>
    public class SinglyLinkedList<T> : IEnumerable<T>
    {
        /// <summary>Внутренний класс элемента списка</summary>
        private class Node
        {
            /// <summary>Ссылка на следующий элемент</summary>
            public Node Next { get; set; }
            /// <summary>Значение элемента</summary>
            public T Value { get; set; }
        }
 
        /// <summary>Первый элемент списка</summary>
        private Node Head { get; set; }
        /// <summary>Последний элемент списка</summary>
        private Node Tail { get; set; }
 
        /// <summary>Добавление элемента в конец списка</summary>
        /// <param name="t">Значение элемнта</param>
        public void Add(T t)
        {
            Node node = new Node() { Value = t };
            if (Head == default)
                Head = Tail = node;
            else
            {
                Tail.Next = node;
                Tail = node;
            }
        }
 
        /// <summary>Добавление последовательности элементов в конец списка</summary>
        /// <param name="items">Последовательность элементов</param>
        public void AddRange(IEnumerable<T> items)
        {
            if (items == null)
                throw new ArgumentNullException(nameof(items));
 
            foreach (T item in items)
                Add(item);
        }
 
        /// <summary>Безпараметрический конструктор</summary>
        public SinglyLinkedList() { }
        /// <summary>Конструктор с заданием начальной коллекции</summary>
        /// <param name="items">Начальная коллекция элементов</param>
        public SinglyLinkedList(IEnumerable<T> items)
            => AddRange(items);
 
 
        public IEnumerator<T> GetEnumerator()
            => new SinglyLinkedListEnumerator(this);
 
        IEnumerator IEnumerable.GetEnumerator()
            => GetEnumerator();
 
        /// <summary>Перечислитель класса SinglyLinkedList</summary>
        public sealed class SinglyLinkedListEnumerator : IEnumerator<T>
        {
            public T Current => CurrentNode == null
                ? throw new InvalidOperationException()
                : CurrentNode.Value;
 
            object IEnumerator.Current => Current;
            private readonly SinglyLinkedList<T> Nodes;
            private Node CurrentNode;
 
            public SinglyLinkedListEnumerator(SinglyLinkedList<T> nodes)
                => Nodes = nodes;
 
            public void Dispose()
            { }
 
            public bool MoveNext()
            {
                if (Nodes == null)
                    return false;
 
                if (CurrentNode == null)
                {
                    if (IsReset)
                    {
                        CurrentNode = Nodes.Head;
                        IsReset = false;
                        return true;
                    }
                    return false;
                }
 
                if (CurrentNode != Nodes.Tail)
                {
                    CurrentNode = CurrentNode.Next;
                    return true;
                }
                CurrentNode = null;
                return false;
            }
            private bool IsReset = true;
            public void Reset()
            {
                CurrentNode = null;
                IsReset = true;
            }
        }
 
    }

            SinglyLinkedList<int> list = new SinglyLinkedList<int>() { 1, 3, 2, 5, 4, 7, 6, 9, 8, 0 };
            list.AddRange(new int[] {12, 34, 56, 78, 90, 10, 32, 54, 76, 98 });
 
            Console.WriteLine(string.Join(", ", list));

public class MyList<T> : List<T>
{
   /// Здесь добавить перегрузку операторов
}