class Program
{
    class MyClass
    {
        public void MyMethod() { }
    }
 
    static void Main(string[] args)
    {
        // Variável declarada possui o valor null.
        // Porém, o compilador considera como "unassigned".
        // ou sem valor atribuido. Um erro será gerado
        // ao tentar usar a variável neste momento
        MyClass mc;
 
        // Agora a variável pode ser utilizada, mas...
        mc = null;
 
        // A chamada de um método de um objeto nulo
        // gera um erro de execução - NullReferenceException.
        // Decomente esta linha para ver o resultado.
        // mc.MyMethod();
 
        // Agora, a objeto mc possui um valor, ou referência.
        mc = new MyClass();
 
        // E seu método pode ser chamado.
        mc.MyMethod();
 
        // Definir o objeto para null novamente fará com que seu conteúdo ou
        // referência seja perdido ou descartado, podendo porém receber novos valores.
        mc = null;
 
        // Lembrando que uma string vazia é diferente de uma string nula.
        string s = null;
        string t = String.Empty; // O mesmo que ""
 
        // O método Equals aplicado em objetos nulos sempre retornará false.
        bool b = (t.Equals(s));
        Console.WriteLine(b);
 
        // Operador de igualdade também retorna false ao comparar com um
        // objeto é nulo
        Console.WriteLine("Empty string {0} null string", s == t ? "igual": "diferente");
 
        // Retorna true.
        Console.WriteLine("null == null is {0}", null == null);
 
        // Tipos por valor ou primitivos não podem receber o valor null
       // int i = null; // Erro de compilação!
 
        // O C# 2.0 introduziu os tipos anuláveis, promovendo maior flexibilidade
        int? i = null;
 
        // Mantém a janela do console aberta.
        System.Console.WriteLine("Pressiona qualquer tecla para sair.");
        System.Console.ReadKey();
 
    }
}