У меня было задание создать класс для хэширования в строку

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
 
namespace lab3
{
    class StringHashTable
    {
        private int _count;
        private const int _hashModulo = 1000;
        private List< Tuple <string, string> >[] _table;
 
        public int Count
        {
            get
            {
                return _count;
            }
        }
 
 
        public StringHashTable()
        {
            _count = 0;
            _table = new List< Tuple<string, string> >[_hashModulo];
 
            for (int i = 0; i < _hashModulo; i++)
            {
                _table[i] = new List<Tuple<string,string>>();
            }
        }
 
        public void Add(string key, string value)
        {
            if (Contains(key))
            {
                return;
            }
            int hash = GetHash(key);
            _table[hash].Add(new Tuple<string, string>(key, value));
            _count++;            
        }
 
        public bool Contains(string key)
        {
            int hash = GetHash(key);
            return -1 != _table[hash].FindIndex(x => x.Item1 == key);
        }
 
        public string FindByKey(string key)
        {
            int hash = GetHash(key);
 
            foreach (var item in _table[hash])
            {
                if (item.Item1 == key)
                {
                    return item.Item2;
                }
            }
 
            return null;
        }
 
        public void Remove(string str)
        {
            int hash = GetHash(str);
 
            int index = _table[hash].FindIndex(x => x.Item1 == str);
 
            if (index != -1)
            {
                _table[hash].RemoveAt(index);
                _count--;
            }            
        }
 
        private int GetHash(string str)
        {
            return Math.Abs(str.GetHashCode() % _hashModulo);
        }
 
        public Tuple<string, string>[] ToArray()
        {
            Tuple<string, string>[] arr = new Tuple<string, string>[_count];
 
            int curr = 0;
 
            foreach (var bucket in _table)
            {
                foreach (var item in bucket)
                {
                    arr[curr++] = item;
                }
            }
 
            return arr;
        }
    }
}

str.GetHashCode()

public class LinkedList<T>: IEnumerable<T>
    {
 
        private Element _root;
        private Element _current;
 
        public class Element
        {
            public T Value { get; set; }
            public Element Next { get; set; }
 
            public Element(T value, Element next)
            {
                Value = value;
                Next = next;
            }
        }
        public LinkedList(List<T> list)
        {
            Element result = null;
            Element current = null;
 
            foreach (var item in list)
            {
                var element = new Element(item, null);
                if (current == null)
                {
                    current = element;
                    result = current;
                }
                else
                {
                    current.Next = element;
                    current = current.Next;
                }
            }
            _root = result;
        }
 
        #region IEnumerable<T> Members
 
        public IEnumerator<T> GetEnumerator()
        {
            while(_root!=null)
            {
                _current = _root;
                _root = _root.Next;
                yield return _current.Value;
            }
        }
 
        #endregion
 
        #region IEnumerable Members
 
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
 
        #endregion
    }

static void Main(string[] args)
        {
            var list = new LinkedList<string>(new List<string>{"abc", "asd", "123", "klo"});
 
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }
        }

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
 
namespace ConsoleApplication34
{
    public class MyLinkedList<T> : ICollection<T>
    {
        private class Element
        {
            public Element(T data)
            {
                Data = data;
                Next = null;
            }
 
            public T Data { get; set; }
            public Element Next { get; set; }
        }
 
        private class DefaultComparer : IEqualityComparer<T>
        {
            public bool Equals(T x, T y)
            {
                return x.Equals(y);
            }
 
            public int GetHashCode(T obj)
            {
                return obj.GetHashCode();
            }
        }
 
        private Element head, tail;
        private readonly IEqualityComparer<T> comparer;
 
        public MyLinkedList(IEqualityComparer<T> comparer, bool isReadOnly)
        {
            Count = 0;
            this.comparer = comparer;
            IsReadOnly = isReadOnly;
        }
 
        public MyLinkedList(bool isReadOnly)
            : this(new DefaultComparer(), isReadOnly)
        {
        }
 
        public MyLinkedList(IEqualityComparer<T> comparer)
            : this(comparer, false)
        {
        }
 
        public MyLinkedList()
            : this(new DefaultComparer(), false)
        {
        }
 
        public IEnumerator<T> GetEnumerator()
        {
            for (Element element = head; element != null; element = element.Next)
                yield return element.Data;
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
 
        public void Add(T item)
        {
            var elm = new Element(item);
            if (head == null)
                head = tail = elm;
            else
            {
                tail.Next = elm;
                tail = elm;
            }
            Count++;
        }
 
        public void Clear()
        {
            Count = 0;
            head = tail = null;
        }
 
        public bool Contains(T item)
        {
            return GetElement(item) != null;
        }
 
        private Element GetElement(T item)
        {
            for (Element element = head; element != null; element = element.Next)
                if (comparer.Equals(item, element.Data))
                    return element;
            return null;
        }
 
        public void CopyTo(T[] array, int arrayIndex)
        {
            Array.Copy(this.ToArray(), 0, array, arrayIndex, Count);
        }
 
        public bool Remove(T item)
        {
            if (IsReadOnly)
                throw new NotSupportedException();
            Element element;
            for (element = head;
                 element.Next != null && !comparer.Equals(item, element.Next.Data);
                 element = element.Next)
            {
            }
            if (element.Next == null)
                return false;
            element.Next = element.Next.Next;
            Count--;
            return true;
        }
 
        public int Count { get; private set; }
        public bool IsReadOnly { get; private set; }
    }
 
    public class Program
    {
        private static void Main()
        {
            var list = new MyLinkedList<int>();
            for (int i = 0; i < 5; i++)
            {
                list.Add(i);
            }
            foreach (int i in list)
                Console.Write(i + " ");
            list.Remove(4);
            Console.WriteLine();
            foreach (int i in list)
                Console.Write(i + " ");
            list.Clear();
            Console.ReadKey();
        }
    }
}