Listas enlazadas C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace ListasEnlazadas
{
    class Program
    {
        static void Main(string[] args)
        {
            ListaEnlazable lista = new ListaEnlazable();

            for (int i = 0; i < 10; i++)
            {
                 lista.Add(i+"angel");
            }

            for (int i = 0; i < lista.Count; i++)
            {
                Console.Write(lista[i] +"\n");
            }


            Console.Write("\n");

            lista.Insert(3, "lopez");

            for (int i = 0; i < lista.Count; i++)
            {
                Console.Write(lista[i] + "\n");
            }

            string a = lista[3].ToString();
       


        }



        public class Nodo
        {

 
            public object  valor;//valor del nodo
            public Nodo proximo;//Enlace con otro nodo

            //Al constructor le pasamos un valor y un nodo próximo
            public Nodo(object valor, Nodo proximo)
            {
                this.valor = valor;
                this.proximo = proximo;
            }

            //O le pasamos un valor y por defecto el nodo próximo es null
            public Nodo(object valor): this(valor,null) {}

           
        }


        public class ListaEnlazable:IList
        {
            Nodo primero, ultimo;
            int contador;


            public ListaEnlazable()
            {
                //Inicializamos primero y último vacios
                primero = ultimo = new Nodo(null);
                contador = 0;
            }

       

            #region IList Members


            public int Add(object x)
            {
                //Nodo auxiliar con valor x
                Nodo elem = new Nodo(x);

                if (contador == 0)
                {
                    //Si la lista está vacia
                    primero = elem;
                }
                else
                {
                    //Enlazo el nuevo nodo desde el último
                    ultimo.proximo = elem;
                }

                contador++;
                //actualizo último
                ultimo = elem;

                return 0;
            }

            public void Insert(int index, object x)
            {
                //El índice está fuera de del array
                if (index < 0 || index > contador)
                    throw new IndexOutOfRangeException();

                //Creamos un nodo para recorrer la lista
                Nodo temp = primero;

                //Recorremos los nodos hasta la posición index-1

                for (int i = 0; i < index - 1; i++)
                    temp = temp.proximo;

                //Creamos un nuevo nodo con el valor x y lo enlazamos
                //con el nodo de la posición index

                Nodo nuevo = new Nodo(x, temp.proximo);
                temp.proximo = nuevo;
                contador++;

            }

            public int IndexOf(object x)
            {
               //Recorremos los nodos como vimos en el método anterior
                Nodo temp = primero;

                for (int i = 0; i < contador; i++)
                {
                    //si encontramos x
                    if (temp.valor.Equals(x))
                        //se retorna la posición
                        return i;
                    temp = temp.proximo;
                }

                //Si no está, retornamos -1
                return -1;
            }

            public bool Contains(object x)
            {
                //Retornamos true si el método devuelve un índice positivo
                return (IndexOf(x) >= 0);
             
            }

            public void Remove(object x)
            {
                Nodo temp = primero;

                for (int i = 0; i < contador; i++)
                {

                    if (temp.valor.Equals(x))
                        temp = temp.proximo;
                }

            }

            public int Count
            {
                get { return contador; }
            }

            public object this[int index]
            {
                //aquí programamos como acceder al elemento
                get
                {
                    if (index >= 0 && index < contador)
                    {

                        Nodo cursor = primero;

                        for (int i = 0; i < index; i++)
                            cursor = cursor.proximo;

                        //se retorna el valor que está en index
                        return cursor.valor;
                   
                    }
                    else throw new IndexOutOfRangeException("Indice fuera de rango");
                }
                //Aquí programamos como darle un valor al elemento
                //que está en la posición index
                set
                {

                    if (index >= 0 && index < contador)
                    {

                        Nodo cursor = primero;
                        for (int i = 0; i < index; i++)
                            cursor = cursor.proximo;

                        //cambiamos el valor del elemento que está en el index
                        cursor.valor = value;

                    }
                    else throw new IndexOutOfRangeException("Indice fuera de rango");

                }

            }


           
            public void Clear()
            {
                throw new NotImplementedException();
            }
                 
            public bool IsFixedSize
            {
                get { throw new NotImplementedException(); }
            }

            public bool IsReadOnly
            {
                get { throw new NotImplementedException(); }
            }
         
            public void RemoveAt(int index)
            {
                throw new NotImplementedException();
            }
           

            #endregion

            #region ICollection Members
           
            public void CopyTo(Array array, int index)
            {
                throw new NotImplementedException();
            }

            public bool IsSynchronized
            {
                get { throw new NotImplementedException(); }
            }

            public object SyncRoot
            {
                get { throw new NotImplementedException(); }
            }
           
            #endregion

            #region IEnumerable Members
           
            public IEnumerator GetEnumerator()
            {
                throw new NotImplementedException();
            }
           
            #endregion
        }



    }
}