Classes Genéricas: Lista Ligada em C#

Esse post não será mais atualizado nesse blog. Para visualizar esse post em seu novo endereço, acesse:
http://milaneze.com.br/post/2011/05/15/Classes-Genericas-Lista-Ligada-em-C.aspx


Estou lendo o livro da certificação em .NET e tem esse exercício no primeiro capítulo: criar uma lista ligada usando classses genéricas em C#. Fiz uma bem rápido e estou postando aqui como um exemplo de classes genéricas (não ligue muito para o algoritmo, por favor).

Essa classe aceita qualquer tipo, mas caso quisesse restringir os tipos que podem ser aceitos, usaria "public class ListaLigada where T : IDisposable", por exemplo, para aceitar somente tipos que implementem a interface IDisposable.

Abaixo, segue o código de exemplo:

public class ListaLigadaNo<T>
{
    private ListaLigadaNo<T> _Proximo;

    public ListaLigadaNo<T> Proximo
    {
        get { return _Proximo; }
        internal set { _Proximo = value; }
    }

    private T _valor;

    public ListaLigadaNo(T valor)
    {
        _valor = valor;
    }

    public override string ToString()
    {
        return _valor.ToString();
    }
}

public class ListaLigada<T>
{
    private ListaLigadaNo<T> _Primeiro;
    private ListaLigadaNo<T> _Ultimo;
    private int _Count;


    public int Count
    {
        get { return _Count; }
    }

    public ListaLigadaNo<T> Ultimo
    {
        get { return _Ultimo; }
    }

    public ListaLigadaNo<T> Primeiro
    {
        get { return _Primeiro; }
    }

    public ListaLigada()
    {
        _Primeiro = null;
        _Ultimo = null;
        _Count = 0;
    }

    public override string ToString()
    {
        StringBuilder _sbRetorno = new StringBuilder();

        ListaLigadaNo<T> _noAtual = _Primeiro;

        while (_noAtual != null)
        {
            _sbRetorno.AppendFormat("{0};", _noAtual.ToString());
            _noAtual = _noAtual.Proximo;
        }

        return _sbRetorno.ToString();
    }

    public void AdicionarPrimeiro(T valor)
    {
        ListaLigadaNo<T> _PrimeiroAux = _Primeiro;
        _Primeiro = new ListaLigadaNo<T>(valor);
        _Primeiro.Proximo = _PrimeiroAux;

        if (_PrimeiroAux == null)
            _Ultimo = _Primeiro;

        _Count++;
    }

    public void AdicionarUltimo(T valor)
    {
        ListaLigadaNo<T> _UltimoAux = _Ultimo;
        _Ultimo = new ListaLigadaNo<T>(valor);
        _Ultimo.Proximo = null;

        if (_UltimoAux == null)
            _Primeiro = _Ultimo;
        else
            _UltimoAux.Proximo = _Ultimo;

        _Count++;
    }

    public void AdicionarDepois(ListaLigadaNo<T> No, T valor)
    {
        if (_Primeiro == null)
        {
            _Primeiro = No;
            _Ultimo = new ListaLigadaNo<T>(valor);
            _Ultimo.Proximo = null;
            _Primeiro.Proximo = _Ultimo;
        }
        else
        {
            ListaLigadaNo<T> _ProxAux = No.Proximo;
            No.Proximo = new ListaLigadaNo<T>(valor);
            No.Proximo.Proximo = _ProxAux;

            if (_ProxAux == null)
                _Ultimo = No.Proximo;
        }

        _Count++;
    }
}

class Program
{
    static void Main(string[] args)
    {
        ListaLigada<int> _ListaLigada = new ListaLigada<int>();

        _ListaLigada.AdicionarUltimo(-2);
        _ListaLigada.AdicionarPrimeiro(0);
        _ListaLigada.AdicionarUltimo(-2);

        for (int i = 1; i <= 100; i++)
            _ListaLigada.AdicionarDepois(_ListaLigada.Ultimo, i);

        _ListaLigada.AdicionarPrimeiro(-1);
        _ListaLigada.AdicionarUltimo(-2);
        

        Console.WriteLine(_ListaLigada.ToString());
        Console.WriteLine("Primeiro: {0}", _ListaLigada.Primeiro.ToString());
        Console.WriteLine("Último: {0}", _ListaLigada.Ultimo.ToString());
        Console.WriteLine("Contagem: {0}", _ListaLigada.Count.ToString());

        Console.ReadLine();
    }
}