Exceções de solução de problemas: System.NullReferenceException

Uma NullReferenceException ocorre quando você tenta utilizar um método ou propriedade de um tipo de referência (C#, Visual Basic) cujo valor é null. Por exemplo, talvez você tenha tentado utilizar um objeto sem usar primeiro a palavra-chave nova (Nova no Visual Basic), ou tentado utilizar um objeto cujo valor foi definido como nulo (Nada no Visual Basic).

Seções deste artigo

Classes usadas neste artigo

causas comuns de NullReferenceExceptions

Localizando a fonte de NullReferenceExceptions durante o desenvolvimento

evitar NullReferenceExceptions

tratar NullReferenceExceptions em código da versão

Classes usadas neste artigo

A maioria dos exemplos nesse artigo usa uma ou ambas das seguintes classes:

public class Automobile
{
    public EngineInfo Engine {get; set;}
}

public class EngineInfo
{
    public EngineInfo() { }

    public EngineInfo(string powerSrc, double engineSize)
    {
        Power = powerSrc;
        Size = engineSize;
    }

    public double Size { get; set; }
    public string Power = null;
}
   

Public Class Automobile
    Public Property Engine As EngineInfo
End Class

Public Class EngineInfo
    Public Sub New()
    End Sub

    Public Sub New(powerSrc As String, engineSize As Double)
        Power = powerSrc
        Size = engineSize
    End Sub

    Public Property Size() As Double
    Public Power As String = Nothing
End Class

Outras seções neste artigo

Causas comuns de NullReferenceExceptions

Qualquer variável de tipo de referência pode ser nula. Variáveis locais, as propriedades de uma classe, parâmetros de método e valores de retorno de método, podem todos conter uma referência nula. Chamar métodos ou propriedades dessas variáveis quando eles são nulos causa uma NullReferenceException. Casos específicos:

Um campo de membro ou de variável local é declarado mas não inicializado

uma propriedade ou campo é nulo

um parâmetro de método é nulo

o valor de retorno de um método é nulo

um objeto de uma coleção ou matriz é nulo

um objeto não será criado devido a uma condição

um objeto passado por referência a um método é definido como null

Uma variável local ou campo de membro é declarado mas não inicializado

Esse erro simples acontece com mais frequência no código do Visual Basic. Exceto em situações como na declaração de uma variável a ser passada como um parâmetro de saída, o compilador C# não permite que você utilize uma variável de referência local sem inicializá-la. O compilador Visual Basic gera um aviso.

• No seguinte código C#, a linha realçada gera esse erro do compilador:

• No código Visual Basic a linha realçada no código gera o aviso do compilador BC42104:

  E a linha lança uma NullReferenceException quando executada.

public void NullReferencFromUninitializedLocalVariable()
{
    EngineInfo engine;
    Console.WriteLine(engine.ToString());
}

Public Sub NullReferencFromUninitializedLocalVariable()
    Dim engine As EngineInfo
    Console.WriteLine(engine.ToString())
End Sub

Entradas nesta seção

Seções deste artigo

Uma propriedade ou campo é nulo

Esses campos e propriedades de uma classe são inicializados automaticamente para seu valor padrão quando a classe é criada. O valor padrão de um tipo de referência é null (Nothing no Visual Basic). Chamar métodos de membros em um campo ou propriedade de uma classe pai quando o valor de campo ou propriedade é nulo causa uma NullReferenceException.

Nesse exemplo, a linha realçada lança uma NullReferenceException porque a propriedade Engine de car é autoinicializada como nula.

public void NullReferenceFromProperty()
{
    var car = new Automobile();

    Console.WriteLine(car.Engine.ToString());
}

Public Sub NullReferenceFromProperty()
    Dim car = New Automobile()
    Console.WriteLine(car.Engine.ToString())
End Sub

Entradas nesta seção

Seções deste artigo

Um parâmetro de método é nulo

Um parâmetro de método que é um tipo de referência pode ser null (Nothing no Visual Basic). Chamar métodos ou propriedades de membros em um valor de parâmetro nulo causa uma NullReferenceException.

Nesse exemplo, a linha realçada lança uma NullReferenceException porque BadEngineInfoPassedToMethod chama NullReferenceFromMethodParameter com um parâmetro nulo.

public void BadEngineInfoPassedToMethod()
{
    EngineInfo eng = null;
    NullReferenceFromMethodParameter(eng);
}

public void NullReferenceFromMethodParameter(EngineInfo engine)
{
    Console.WriteLine(engine.ToString());
}

Public Sub BadParameterPassedToMethod() As EngineInfo
    Dim eng As EngineInfo = Nothing
    NullReferenceFromMethodParameter(eng)
End Sub

Public Sub NullReferenceFromMethodParameter(engine As EngineInfo)
    Console.WriteLine(engine.ToString())
End Sub

Entradas nesta seção

Seções deste artigo

O valor retornado de um método é nulo

Um método que retorna um tipo de referência pode retornar null (Nothing no Visual Basic). Chamar métodos ou propriedades do tipo de referência retornada causa uma NullReferenceException quando a referência é nula.

Nesse exemplo, a linha realçada lança uma NullReferenceException porque a chamada para BadGetEngineInfo retorna uma referência nula no método NullReferenceFromMethodParameter.

public EngineInfo BadGetEngineInfo()
{
    EngineInfo engine = null;
    return engine;
}

public void NullReferenceFromMethodReturnValue()
{
    var engine = BadGetEngineInfo();
    Console.WriteLine(engine.ToString());
}

Public Function BadGetEngineInfo() As EngineInfo
    Dim engine As EngineInfo = Nothing
    Return engine
End Function

Public Sub NullReferenceFromMethodReturnValue()
    Dim engine = BadGetEngineInfo()
    Console.WriteLine(engine.ToString())
End Sub

Entradas nesta seção

Seções deste artigo

Um objeto em uma coleção ou matriz é nulo

Uma lista ou matriz de tipos de referência pode conter um item nulo. Chamar métodos ou propriedades de um item de lista nulo causa uma NullReferenceException.

Nesse exemplo, a linha realçada em NullReferenceFromListItem() lança uma NullReferenceException porque a chamada para BadGetCarList retorna um item nulo.

public Automobile[] BadGetCarList()
{
    var autos = new Automobile[10];
    for (int i = 0; i autos.Length; i++)
    {
        if (i != 6)
        {
            autos[i] = new Automobile();
        }
    }
    return autos;
}

public void NullReferenceFromListItem()
{
    var cars = BadGetCarList();
    foreach (Automobile car in cars)
    {
        Console.WriteLine(car.ToString());
    }
}

Public Function BadGetCarList() As Automobile()
    Dim autos = New Automobile(10) {}
    For i As Integer = 0 To 9
        If i <> 6 Then
            autos(i) = New Automobile()
        End If
    Next
    Return autos
End Function

Public Sub NullReferenceFromListItem()
    Dim cars = BadGetCarList()
    For Each car As Automobile In cars
        Console.WriteLine(car.ToString())
    Next
End Sub

Entradas nesta seção

Seções deste artigo

Um objeto não é criado devido a uma condição

Se um tipo de referência é inicializado em um bloco condicional, o objeto não é criado quando a condição é falsa.

Neste exemplo, a linha realçada na NullReferenceFromConditionalCreation gera uma NullReferenceException porque ele inicializa o engine variável apenas se o DetermineTheCondition() método retornará true.

 public bool DetermineTheCondition()
{
    return false;
}

public void NullReferenceFromConditionalCreation()
{
    EngineInfo engine = null;
    var condition = DetermineTheCondition();
    if (condition)
    {
        engine = new EngineInfo();
        engine.Power = "Diesel";
        engine.Size = 2.4;
    }
    Console.WriteLine(engine.Size);
}

Public Function DetermineTheCondition() As Boolean
    Return False
End Function

Public Sub NullReferenceFromConditionalCreation()
    Dim engine As EngineInfo = Nothing
    Dim condition = DetermineTheCondition()
    If condition Then
        engine = New EngineInfo()
        engine.Power = "Diesel"
        engine.Size = 2.4
    End If
    Console.WriteLine(engine.Size)
End Sub

Entradas nesta seção

Seções deste artigo

A propriedade de um objeto passada para um método é definida como nula

Quando um objeto é passado como um parâmetro para um método por valor (sem o uso da ref ou out palavra-chave em c# ou o ByRef palavra-chave no Visual Basic), o método não é possível alterar o local da memória do parâmetro — o que o parâmetro aponta para — mas ele pode alterar as propriedades do objeto.

Neste exemplo, o método NullPropertyReferenceFromPassToMethod cria um objeto Automobile e inicializa a propriedade Engine. Em seguida, chama BadSwapCarEngine passando o novo objeto como o parâmetro. BadSwapCarEnginedefine a propriedade do mecanismo como nulo, o que faz com que a linha realçada no NullPropertyReferenceFromPassToMethod lance uma NullReferenceException.

public void BadSwapCarEngine(Automobile car)
{
    car.Engine = null;
}

public void (Automobile car)
{
    car.Engine = new EngineInfo("GAS", 1.5);
    BadSwapCarEngine(car);
    Console.WriteLine(car.Engine.ToString());
}

Public Sub BadSwapCarEngine(car As Automobile)
    car.Engine = Nothing
End Sub

Public Sub NullPropertyReferenceFromPassToMethod()
    Dim car As New Automobile()
    car.Engine = New EngineInfo("GAS", 1.5)
    BadSwapCarEngine(car)
    Console.WriteLine(car.Engine.ToString())
End Sub

Entradas nesta seção

Seções deste artigo

Um objeto passado por referência para um método é definido como nulo

Quando você passa um tipo de referência como um parâmetro para um método por referência (usando o ref ou out palavra-chave em c# ou o ByRef palavra-chave no Visual Basic), você pode alterar o local da memória que o parâmetro aponta para.

Se você passa um tipo de referência por referência para um método, o método pode definir o tipo referenciado como null (Nothing no Visual Basic).

Nesse exemplo a linha realçada em NullReferenceFromPassToMethodByRef lança uma NullReferenceException porque a chamada para a chamada do método BadEngineSwapByRef define a variável stockEngine como nula.

public void BadEngineSwapByRef(ref EngineInfo engine)
{
    engine = null;
}

public void NullReferenceFromPassToMethodByRef()
{
    var stockEngine = new EngineInfo();
    stockEngine.Power = "Gas";
    stockEngine.Size = 7.0;
    BadSwapEngineByRef(ref stockEngine);
    Console.WriteLine(stockEngine.ToString());
}

Public Sub BadSwapEngineByRef(ByRef engine As EngineInfo)
    engine = Nothing
End Sub

Public Sub NullReferenceFromPassToMethodByRef()
    Dim formatStr = "The stock engine has been replaced by a {0} liter {} engine"
    Dim stockEngine = New EngineInfo()
    stockEngine.Power = "Gas"
    stockEngine.Size = 7.0
    BadSwapEngineByRef(stockEngine)
    Console.WriteLine(stockEngine.ToString())
End Sub

Entradas nesta seção

Seções deste artigo

Localizar a fonte de uma exceção de referência nula durante o desenvolvimento

Usar dicas de dados, a janela locais e janelas de inspeção para ver os valores de variáveis

movimentar a pilha de chamadas para localizar onde uma variável de referência não é inicializado ou definida como null

definir pontos de interrupção condicionais para parar a depuração quando um objeto é nulo (Nothing no Visual Basic)

Utilizar dicas de dados, a janela Locais e as janelas de inspeção para consultar os valores variáveis

• Descanse o ponteiro sobre o nome da variável para ver seu valor em uma dica de dados. Se a variável fizer referência a um objeto ou a uma coleção, você pode expandir o tipo de dados para examinar suas propriedades ou elementos.

• Abra o locais janela para examinar as variáveis que estão ativas no contexto atual.

• Utilize uma janela inspeção para se concentrar em como uma variável sofre alteração à medida que você passa pelo código.

Entradas nesta seção

Seções deste artigo

Movimentar a pilha de chamadas para localizar onde uma variável de referência não é inicializado ou definida como null

A janela Pilha de Chamadas do Visual Studio exibe uma lista dos nomes de métodos que não foram concluídos quando o depurador para em uma exceção ou ponto de interrupção. Você pode selecionar um nome na janela Pilha de Chamadas e escolher Alternar para quadro para alterar o contexto de execução para o método e examinar suas variáveis.

Entradas nesta seção

Seções deste artigo

Configurar os pontos de interrupção condicionais para parar a depuração quando um objeto é nulo (Nada no Visual Basic)

Você pode configurar uma condição de ponto de interrupção para interromper uma variável quando ela for nula. Condições de pontos de interrupção podem ser úteis quando a referência nula não ocorre com frequência, como quando um item na coleção é nulo apenas intermitentemente. Outra vantagem de pontos de interrupção condicionais é que eles permitem que você depure um problema antes de se comprometer com uma rotina de tratamento específica.

Entradas nesta seção

Seções deste artigo

Evitar NullReferenceExceptions

Usar Assert para confirmar uma invariável

totalmente inicializada tipos de referência

Utilizar Debug.Assert para confirmar uma invariante

Uma invariante é uma condição que você tem certeza que é verdadeira. Uma instrução Debug.Assert (System.Diagnostics) é chamada apenas de compilações de depuração de seus aplicativos e não é chamada a partir do código da versão. Se a condição invariante não é verdadeira, o depurador para na instrução Assert e exibe uma caixa de diálogo. Debug.Assert verifica se a condição não foi alterada durante o desenvolvimento do aplicativo. Uma declaração também documenta para outras pessoas que leem o código que a condição deve sempre ser verdadeira.

Por exemplo, o método MakeEngineFaster pressupõe que seu parâmetro engine nunca será nulo porque seu único método de chamada (TheOnlyCallerOfMakeEngineFaster) conhecido por inicializar totalmente o EngineInfo. A declaração em MakeEngineFaster documenta a suposição e fornece uma verificação de que a suposição é verdadeira.

Se alguém adicionar um novo método de chamada (BadNewCallerOfMakeEngineFaster) que não inicializa o parâmetro, a declaração será acionada.

private void TheOnlyCallerOfMakeEngineFaster()
{
    var engine = new EngineInfo();
    engine.Power = "GAS";
    engine.Size = 1.5;
    MakeEngineFaster(engine);
}

private void MakeEngineFaster(EngineInfo engine)
{
    System.Diagnostics.Debug.Assert(engine != null, "Assert: engine != null");
    engine.Size *= 2;
    Console.WriteLine("The engine is twice as fast");
}

private void BadNewCallerOfMakeEngineFaster()
{
    EngineInfo engine = null;
    MakeEngineFaster(engine);
}

Public Sub TheOnlyCallerOfMakeEngineFaster()
    Dim engine As New EngineInfo
    engine.Power = "GAS"
    engine.Size = 1.5
    MakeEngineFaster(engine)
End Sub

Private Sub MakeEngineFaster(engine As EngineInfo)
    System.Diagnostics.Debug.Assert(engine IsNot Nothing, "Assert: engine IsNot Nothing")
    engine.Size = engine.Size * 2
    Console.WriteLine("The engine is twice as fast")
End Sub

Public Sub BadNewCallerOfMakeEngineFaster()
    Dim engine As EngineInfo = Nothing
    MakeEngineFaster(engine)
End Sub

Entradas nesta seção

Seções deste artigo

Inicialização total de tipos de referência

Para evitar muitas NullReferenceExceptions, faça a inicialização total de tipos de referência o mais próximo possível de sua criação.

Adicione a inicialização total a suas próprias classes

Se você controla a classe que lança uma NullReferenceException, considere inicializar totalmente o objeto no construtor de tipos. Por exemplo, veja a seguir uma versão revisada das classes de exemplo que garantem a inicialização total:

public class Automobile
{
    public EngineInfo Engine { get; set; }

    public Automobile() 
    { 
        this.Engine = new EngineInfo(); 
    }

    public Automobile(string powerSrc, double engineSize)
    {
        this.Engine = new EngineInfo(powerSrc, engineSize);
    }
}


public class EngineInfo
{
    public double Size {get; set;}
    public string Power {get; set;}

    public EngineInfo() 
    { 
        // the base engine 
        this.Power = "GAS"; 
        this.Size = 1.5; 
    }

    public EngineInfo(string powerSrc, double engineSize)
    {
        this.Power = powerSrc;
        this.Size = engineSize;
    }
}

Public Class Automobile
    Public Property Engine As EngineInfo

    Public Sub New() 
        Me.Engine = New EngineInfo() 
    End Sub 

    Public Sub New(powerSrc As String, engineSize As Double) 
        Me.Engine = New EngineInfo(powerSrc, engineSize) 
    End Sub

End Class

Public Class BaseEngineInfo
    Public Sub New() 
        ' the base engine 
        Me.Power = "GAS" 
        Me.Size = 1.5 
    End Sub

    Public Sub New(powerSrc As String, engineSize As Double)
        Power = powerSrc
        Size = engineSize
    End Sub

    Public Property Size() As Double
    Public Power As String = String.Empty
End Class

Dica

Utilize a inicialização lenta para propriedades grandes ou que não são utilizadas com frequência

Para reduzir o volume de memória de sua classe e para aumentar seu desempenho, recomendamos usar a inicialização lenta de propriedades de tipos de referências.Consulte Inicialização lenta.

Tratar NullReferenceExceptions em código da versão

Verificar antes de usar um tipo de referência nula (Nothing no Visual Basic)

uso try-catch – finalmente (Try-Catch-Finally no Visual Basic) para tratar a exceção

É melhor evitar uma NullReferenceException do que tratá-la depois que ocorrer. Tratar uma exceção pode fazer com que seu código seja difícil de manter e entender e pode, algumas vezes, introduzir outros bugs. Uma NullReferenceException é frequentemente um erro não recuperável. Nesses casos, deixar a exceção interromper o aplicativo pode ser a melhor alternativa.

No entanto, há várias situações em que o tratamento do erro pode ser útil:

• Seu aplicativo pode ignorar objetos nulos. Por exemplo, se seu aplicativo recupera e processa gravações em um banco de dados, você pode ser capaz de ignorar um certo número de gravações ruins que resultam em objetos nulos. Gravar os dados ruins em um arquivo de log ou na interface de usuário do aplicativo pode ser tudo que você precisa fazer.

• Você pode recuperar a partir da exceção. Por exemplo, uma chamada para um serviço Web que retorna um tipo de referência pode retornar nulo se a conexão for perdida ou expirar. Você pode tentar restabelecer a conexão e tentar a chamada de novo.

• Você pode restaurar o estado de seu aplicativo para um estado válido. Por exemplo, pode ser que você esteja realizando uma tarefa de várias etapas que requer que as informações sejam salvas em um armazenamento de dados antes de chamar um método que lança uma NullReferenceException. Se o objeto não inicializado corromper a gravação de dados, você poderá remover os dados anteriores antes de fechar o aplicativo.

• Você deseja reportar a exceção. Por exemplo, se o erro foi causado por um erro do usuário de seu aplicativo, você pode gerar uma mensagem para ajudá-lo a fornecer as informações corretas. Você pode também registrar informações sobre o erro para ajudá-lo a solucionar o problema. Algumas estruturas, como o ASP.NET, tem um manipulador de exceção de alto nível que captura todos os erros para que o aplicativo nunca falhe; nesse caso, a exceção de registro em log pode ser a única maneira de saber que ele ocorre.

Estas são duas maneiras de manipular NullReferenceException no código da versão.

Verifique se há nulos (Nada no Visual Basic) antes de usar um tipo de referência

Utilizando um teste explícito de nulo antes de utilizar um objeto evita a penalidade de desempenho de construtores try-catch-finally. No entanto, você ainda precisa determinar e implementar o que fazer em resposta ao objeto não inicializado.

Neste exemplo, o CheckForNullReferenceFromMethodReturnValue testa o valor de retorno do método BadGetEngineInfo. Se o objeto não é nulo, ele é utilizado, caso contrário, o método reporta o erro.

public EngineInfo BadGetEngineInfo()
{
    EngineInfo engine = null;
    return engine;
}

public void CheckForNullReferenceFromMethodReturnValue()
{
    var engine = BadGetEngineInfo();
    if(engine != null)
    {
        // modify the info
        engine.Power = "DIESEL";
        engine.Size = 2.4;
    }
    else
    {
        // report the error
        Console.WriteLine("BadGetEngine returned null")
    }
}

public EngineInfo BadGetEngineInfo()
{
    EngineInfo engine = null;
    return engine;
}
Public Sub CheckForNullReferenceFromMethodReturnValue()
    Dim engine = BadGetEngineInfo()
    If (engine IsNot Nothing) Then
        ' modify the info
        engine.Power = "DIESEL"
        engine.Size = 2.4
    Else
        ' report the error
        Console.WriteLine("BadGetEngineInfo returned Nothing")
    End If

End Sub

Entradas nesta seção

Seções deste artigo

Use try-catch-finally (Try-Catch-Finally no Visual Basic) para tratar a exceção

Usando a construções de manipulação de exceção interna (try, catch, finally em c#, Try, Catch, Finally no Visual Basic) oferece mais opções para lidar com NullReferenceExceptions que verificar se um objeto não é nulo.

No exemplo, CatchNullReferenceFromMethodCall utiliza dois asserts para confirmar a suposição de que o parâmetro contém um automóvel completo, incluindo um motor. No bloco try a linha realçada lança uma NullReferenceException porque a chamada para RarelyBadEngineSwap pode destruir a propriedade Engine do carro. O bloco catch captura a exceção, grava a informação sobre exceção em um arquivo e relata o erro ao usuário. No bloco finally, o método assegura que o estado do carro não seja pior do que quando o método começou.

public void RarelyBadSwapCarEngine(Automobile car)
{
    if ((new Random()).Next() == 42)
    {
        car.Engine = null;
    }
    else
    {
        car.Engine = new EngineInfo("DIESEL", 2.4);
    }
}

public void CatchNullReferenceFromMethodCall(Automobile car)
{
    System.Diagnostics.Debug.Assert(car != null, "Assert: car != null");
    System.Diagnostics.Debug.Assert(car.Engine != null, "Assert: car.Engine != null");

    // save current engine properties in case they're needed
    var enginePowerBefore = car.Engine.Power;
    var engineSizeBefore = car.Engine.Size;

    try
    {
        RarelyBadSwapCarEngine(car);
        var msg = "Swap succeeded. New engine power source: {0} size {1}";
        Console.WriteLine(msg, car.Engine.Power, car.Engine.Size);
    }
    catch(NullReferenceException nullRefEx)
    {
        // write exception info to log file
        LogException(nullRefEx);
        // notify the user
        Console.WriteLine("Engine swap failed. Please call your customer rep.");
    }
    finally
    {
        if(car.Engine == null)
        {
            car.Engine = new EngineInfo(enginePowerBefore, engineSizeBefore);
        }
    }
}

Public Sub RarelyBadSwapCarEngine(car As Automobile)
    If (New Random()).Next = 42 Then
        car.Engine = Nothing
    Else
        car.Engine = New EngineInfo("DIESEL", 2.4)
    End If
End Sub

Public Sub CatchNullReferenceFromMethodCall(car As Automobile)
    System.Diagnostics.Debug.Assert(car IsNot Nothing)
    System.Diagnostics.Debug.Assert(car.Engine IsNot Nothing)

    ' save current engine properties in case they're needed
    Dim powerBefore = car.Engine.Power
    Dim sizeBefore = car.Engine.Size

    Try
        RarelyBadSwapCarEngine(car)
        Dim msg = "Swap succeeded. New engine power source: {0} size {1}"
        Console.WriteLine(msg, car.Engine.Power, car.Engine.Size)
    Catch nullRefEx As NullReferenceException
        ' write exception info to log file
        LogException(nullRefEx)
        ' notify user
        Console.WriteLine("Engine swap failed. Please call your customer rep.")
    Finally
        If car.Engine Is Nothing Then car.Engine = New EngineInfo(powerBefore, sizeBefore)
    End Try

End Sub

Entradas nesta seção

Seções deste artigo

Artigos relacionados

Diretrizes de design para exceções (diretrizes de Design do .NET Framework)

manipulando e lançando exceções (Essentials de aplicativo do .NET Framework)

como: receber notificações de exceção de primeira Chance (guia de desenvolvimento do .NET Framework)

como: manipular exceções em uma consulta PLINQ (guia de desenvolvimento do .NET Framework)

Exceções em Threads gerenciados (guia de desenvolvimento do .NET Framework)

exceções e manipulação de exceções (guia de programação c#)

(referência de c#) instruções de manipulação de exceção

Try...Catch...Instrução Finally (Visual Basic)

tratamento de exceções (F #)

exceções em C++ c++ /CLI

(Task Parallel Library) de manipulação de exceção

tratamento de exceções (depuração)

passo a passo: Manipulando uma exceção de simultaneidade (acesso a dados no Visual Studio)

como: manipular erros e exceções que ocorrem com ligação de dados (Windows Forms)

tratamento de exceções em aplicativos de rede (XAML) (Windows)

Seções deste artigo