Definições – Avançado (POO)

Especialização
A especialização nada mais é do que a parte que “especializa” o objeto vindo de uma Generalização, trazer características próprias para o objeto. Seria o mesmo que olhar o diagrama acima de baixo para cima.
Veja:
O objeto Administrador  especializa o objeto Usuario que por sua vez especializa o objeto Pessoa.    

Delagates
Os delegates  são ponteiros para funções (métodos).

O que são ponteiros?
Ponteiro é um valor atribuído em memória que aponta para outro valor em memória através de seu endereço. (não gostei, técnico demais pro meu gosto).  

Quando há a necessidade de usarmos métodos, e ainda não sabemos qual método chamar, pois dependemos de algumas condições, podemos deixar o nosso código mais bonito usando um delegate.   

O delegate irá chamar o método definido de acordo com a nossa necessidade ou condição.   

Veja exemplo:
Abaixo temos um exemplo de uma aplicação Console em C#. 

static class Program
    {
        //declara a assinatura do delegate.
        //os métodos deverão ter a mesma assinatura
        //para que possam ser utilizados pelo delegate
        delegate int Calular(int a, int b);

        static void Main()
        {

            //declara a variável do tipo delegate
            Calular calc;

            //uma condição qualquer
            if (DateTime.Now.Second % 2 == 0)
                //define o método dividir para ser usado no delegate
                calc = new Calular(Dividir);
            else
                //define o método somar para ser usado no delegate
                calc = new Calular(Somar);

            //chama o método
            Console.WriteLine(calc.Invoke(DateTime.Now.Millisecond,
DateTime.Now.Second));

            Console.ReadKey();
        }

        //declara o método somar
        private static int Somar(int a, int b)
        {
            return a + b;
        }

        private static int Dividir(int x, int y)
        {
            return x / y;
        }
    }

Eventos
Eventos são mensagens trocadas pelos sistemas, métodos e objetos para informar um acontecimento, uma ação que se inicia,  que termina dentro da aplicação, como o próprio nome diz, um evento ocorrido.
Vejamos, ao chamar o nosso método Andar() em Pessoa podemos informar que a Pessoa está Andando até que pare de andar , ou podemos informar que a pessoa vai parar de Andar antes de realmente ela parar de Andar. (AntesPararAndar), assim sendo o objeto chamante pode executar alguma ação antes de a Pessoa realmente parar de Andar.  

 Exemplo de eventos em C#:
Para usar eventos em C# temos que fazer uso de delegates como foi visto acima o delegate e um ponteiro para uma função (método), e eventos usam delegates para apontar a qual método o mesmo deverá chamar.   

Declaração de Pessoa

public class Pessoa
    {  
        //declaração da assinatura do delegate
        //que irá tratar os eventos
        public delegate void AndarHandler();

        //este evento irá mostrar que podemos esperar
        //retorno do objeto que chamou
        //o parâmetro pararAndar irá retornar true or false
        //dependendo do caso se for ou não para parar de andar
        public delegate void AndandoHandler(out bool pararAndar);

        //declaração dos eventos
        public event AndarHandler AntesAndar;
        public event AndarHandler AntesPararAndar;

        //repare aqui que iremos usar o segundo delegate
        public event AndandoHandler Andando;
       
        //declaração do método andar
        public void Andar()
        {
            //aqui iremos chamar o evento AntesAndar e avisar
            //o objeto chamante que iremos começar a Andar.
            AntesAndar();

            DateTime pararAs = DateTime.Now.AddSeconds(30);

            //aqui iremos andar por 30 segundos
            while (pararAs > DateTime.Now)
            {
                bool pararAgora = false;
                //aqui iremos notificar que a
                //pessoa continua Andando
                Andando(out pararAgora);

                if (pararAgora)
                {
                    //antes de parar, notificar que vou parar
                    AntesPararAndar();
                    break;
                }

                //aqui apenas iremos parar por um segundo.
                //não se preocupem com esta linha
                System.Threading.Thread.Sleep(1000);
            }
        }
    }

Declaração do objeto para testes.
É uma aplicação do tipo Console. 

static void Main()
        {
            //cria uma pessoa
            Pessoa marcelo = new Pessoa();

            //define os métodos que irão tratar os nossos eventos
            marcelo.Andando +=
new Pessoa.AndandoHandler(marcelo_Andando);
            marcelo.AntesAndar +=
new Pessoa.AndarHandler(marcelo_AntesAndar);
            marcelo.AntesPararAndar +=
new Pessoa.AndarHandler(marcelo_AntesPararAndar);

            //chamar o método para que marcelo possa Andar
            marcelo.Andar();

            Console.WriteLine("Marcelo parou de andar.");

            Console.ReadKey();

        }

        static void marcelo_AntesPararAndar()
        {
            Console.WriteLine("Marcelo irá parar de andar.");
        }

        static void marcelo_AntesAndar()
        {
            Console.WriteLine("Marcelo irá começar a andar.");
        }

        static void marcelo_Andando(out bool pararAndar)
        {
            pararAndar = false;
            //a pessoa marcelo só vai parar se a condição for verdadeira
            if (DateTime.Now.Second % 7 == 0)
                pararAndar = true;

            Console.WriteLine("Marcelo está andando.");
        }