Exercício – Blocos de código e escopo de variável

11 minutos

Um bloco de código é uma ou mais instruções do C# que definem um caminho de execução. As instruções fora do bloco de código afetam quando, se e com que frequência o bloco é executado em tempo de execução. Os blocos de código normalmente são delimitados por chaves, {}.

Além do efeito no caminho de execução, os blocos de código também podem afetar o escopo das variáveis. Os exemplos de código que você examinará durante este exercício ajudarão você a entender a relação entre os blocos de código e o escopo da variável.

Blocos de código afetam o escopo de uma declaração de variáveis

O escopo da variável refere-se à visibilidade dela para os demais códigos do seu aplicativo. Uma variável com escopo local só pode ser acessada dentro do bloco de código no qual ela está definida. Se você tentar acessar a variável fora do bloco de código, obterá um erro do compilador.

O restante desta unidade explora a relação entre os blocos de código e o escopo da variável.

Preparar o ambiente de codificação

Este módulo inclui atividades práticas que orientam você durante o processo de criação e execução do código de demonstração. Incentivamos você a concluir essas atividades usando o Visual Studio Code como ambiente de desenvolvimento. Usar o Visual Studio Code nessas atividades ajudará você a se sentir mais confortável escrevendo e executando o código em um ambiente de desenvolvedor usado por profissionais em todo o mundo.

Abra o Visual Studio Code.

Você pode usar o menu Iniciar do Windows (ou recurso equivalente em outro sistema operacional) para abrir o Visual Studio Code.
No Visual Studio Code, no menu Arquivo, selecione Abrir Pasta.
Na caixa de diálogo Abrir Pasta, navegue até a pasta Área de Trabalho do Windows.

Se você tiver um local de pasta diferente no qual mantém os projetos de código, poderá usar esse local de pasta. Neste treinamento, o importante é ter um local que seja fácil de localizar e lembrar.
Na caixa de diálogo Abrir Pasta, selecione Selecionar Pasta.

Se aparecer uma caixa de diálogo de segurança perguntando se confia nos autores, selecione Sim.
No Visual Studio Code, no menu Terminal, selecione Novo Terminal.

Observe que o prompt de comando no painel Terminal exibe o caminho da pasta atual. Por exemplo:
```
C:\Users\someuser\Desktop>
```
Observação

Se você estiver trabalhando no próprio computador em vez de em uma área restrita ou em um ambiente hospedado e tiver concluído outros módulos do Microsoft Learn desta série C#, talvez já tenha criado uma pasta de projeto para exemplos de código. Se esse for o caso, você poderá ignorar a próxima etapa, que será usada para criar o aplicativo de console na pasta TestProject.
No prompt de comando terminal, para criar um novo aplicativo de console em uma pasta especificada, insira o seguinte prompt:
```
dotnet new console -o ./CsharpProjects/TestProject
```
Este comando da CLI do .NET usa um modelo de programa .NET para criar o novo projeto de aplicativo de console C# no local da pasta especificada. O comando cria as pastas CsharpProjects e TestProject para você e usa TestProject como o nome do arquivo .csproj.

Se uma mensagem for exibida informando que os arquivos já existem, continue com as próximas etapas. Você reutilizará os arquivos de projeto existentes.
No modo de exibição EXPLORER, expanda a pasta CsharpProjects .

Você deverá ver a pasta TestProject e dois arquivos, um arquivo de programa C# chamado Program.cs e um arquivo de projeto em C# chamado TestProject.csproj.
No Visual Studio Code, no menu Arquivo, selecione Abrir Pasta.
Na caixa de diálogo Abrir Pasta , selecione a pasta CsharpProjects e selecione Selecionar Pasta.
No modo de exibição EXPLORER, expanda a pasta TestProject e selecione Program.cs.
Exclua as linhas de código existentes.

Você usará esse projeto de console C# para criar, compilar e executar exemplos de código durante este módulo.
Feche o painel do Terminal.

Criar uma variável dentro de um bloco de código

Você começará examinando o caso em que uma variável é inicializada dentro do bloco de código.

Verifique se o Visual Studio Code está aberto e se o arquivo Program.cs está sendo exibido no painel do Editor.

Observação

Program.cs deve estar vazio. Se não estiver, selecione e exclua todas as linhas de código.

Digite o código de exemplo a seguir no Editor do Visual Studio Code:

bool flag = true;
if (flag)
{
    int value = 10;
    Console.WriteLine($"Inside the code block: {value}");
}

No menu Arquivo do Visual Studio Code, selecione Salvar.

O arquivo Program.cs deve ser salvo antes da compilação ou execução do código.
No painel EXPLORER, para abrir o Terminal no local da pasta TestProject, clique com o botão direito do mouse em TestProject e selecione Abrir no Terminal Integrado.

Um painel Terminal será aberto. O Terminal deve incluir um prompt de comando mostrando que o Terminal está aberto no local da pasta TestProject.
No prompt de comando do Terminal, para executar o código, digite dotnet run e pressione Enter.

Observação

Se você vir a mensagem "Não foi possível encontrar um projeto para executar", verifique se o prompt de comando do Terminal exibe o local esperado da pasta TestProject. Por exemplo: C:\Users\someuser\Desktop\csharpprojects\TestProject>

A seguinte saída deve ser exibida:
```
Inside the code block: 10
```

Essa é a saída esperada. Mas e se você quiser acessar a variável value fora do bloco de código de instrução if?

Tentar acessar uma variável fora do bloco de código no qual ela é declarada

No Editor do Visual Studio Code, crie uma linha de código abaixo do bloco de código da instrução if.
Adicione a seguinte linha de código na linha de código em branco criada:
```
Console.WriteLine($"Outside the code block: {value}");
```

Verifique se o código atualizado é assim:

bool flag = true;
if (flag)
{
    int value = 10;
    Console.WriteLine($"Inside the code block: {value}");
}
Console.WriteLine($"Outside the code block: {value}");

Salve o arquivo de código e use o Visual Studio Code para executar o código.

Insira dotnet run no prompt de comando do Terminal para executar o código.

Observe que, ao tentar executar o aplicativo, você recebe um erro de compilação:

Program.cs(7,46): error CS0103: The name 'value' does not exist in the current context

A parte Program.cs(7,46) da mensagem informa que o erro está associado à linha 7 no arquivo Program.cs, coluna 46.

Esse erro é gerado porque uma variável que é declarada em um bloco de código só é acessível (pode ser vista apenas) dentro desse bloco de código. Como uma variável não pode ser acessada fora do bloco de código no qual é declarada, value não pode ser acessado da linha 7 do código.

Uma variável que é declarada em um bloco de código de método é conhecida como uma variável local. Você pode ver o termo variável local usado ao revisar artigos que discutem o escopo da variável.

Mover a declaração de variável acima do bloco de código

Para acessar uma variável dentro e fora de um bloco de código, será necessário declarar a variável antes (acima) do bloco de código para que o código fora do bloco de código possa "exibir" a variável.

Atualize o código no Editor do Visual Studio Code da seguinte maneira:

bool flag = true;
int value;

if (flag)
{
    Console.WriteLine($"Inside the code block: {value}");
}

value = 10;
Console.WriteLine($"Outside the code block: {value}");

Reserve um minuto para analisar as atualizações.
Observe que value agora é declarada (mas não inicializada) fora do bloco de código if.
Use o Visual Studio Code para salvar suas atualizações e depois execute seu código.
Observe que você ainda recebe um erro de compilação.

Desta vez, ao tentar executar o aplicativo, você obterá o seguinte erro de compilação:
```
Program.cs(6,49): error CS0165: Use of unassigned local variable 'value'
```
O erro está associado à linha 6 dentro do bloco de código porque value não foi inicializado (não teve valor atribuído a ele). Se a linha de código value = 10; fosse localizada acima do bloco de código da instrução if, o aplicativo compilaria corretamente e tudo ficaria bem. No entanto, como value não foi inicializado, ele não pode ser acessado no bloco de código.

Garantir que suas variáveis sejam inicializadas antes de tentar acessá-las resolverá esse problema.

Inicializar uma variável como parte da declaração de variável

Para inicializar value como parte da declaração de variável, atualize o código da seguinte maneira:
```
bool flag = true;
int value = 0;

if (flag)
{
    Console.WriteLine($"Inside the code block: {value}");
}

value = 10;
Console.WriteLine($"Outside the code block: {value}");
```
Esse código aborda o erro de compilação "variável local não atribuída" inicializando value como parte da declaração de variável.
Use o Visual Studio Code para salvar e executar seu código.
Observe que agora, ao executar o aplicativo, a seguinte saída será exibida:
```
Inside the code block: 0
Outside the code block: 10
```

Examinar a interpretação do compilador do código

Para ajudá-lo a evitar erros de runtime, o compilador C# analisa seu código no Editor do Visual Studio Code e durante o processo de compilação. No entanto, o compilador nem sempre interpretará seu código da mesma maneira que você.

Considere os dois exemplos de código a seguir que parecem servir à mesma finalidade:

// Code sample 1
bool flag = true;
int value;

if (flag)
{
    value = 10;
    Console.WriteLine($"Inside the code block: {value}");
}

Console.WriteLine($"Outside the code block: {value}");

// Code sample 2
int value;

if (true)
{
    value = 10;
    Console.WriteLine($"Inside the code block: {value}");
}

Console.WriteLine($"Outside the code block: {value}");

Você pode pensar que esses dois exemplos devem sempre produzir o mesmo resultado, mas o compilador C# interpreta esses dois exemplos de código de forma diferente.

No primeiro exemplo de código, o compilador interpreta flag como uma variável de booliano à qual pode ter atribuída um valor de true ou false. O compilador conclui que, se flag for false, value não será inicializado quando o segundo Console.WriteLine() for executado. Essencialmente, o compilador considera como possíveis os dois caminhos de execução de código a seguir:

// path when flag = true
int value;
value = 10;
Console.WriteLine($"Inside the code block: {value}");
Console.WriteLine($"Outside the code block: {value}");

// path when flag = false
int value;
Console.WriteLine($"Outside the code block: {value}");

Como o compilador considera o segundo caminho uma possibilidade (para o exemplo de código 1), ele gera uma mensagem de erro durante o processo de compilação. Além disso, o Editor de código no Visual Studio Code avisa sobre esse problema exibindo uma linha de rabiscos vermelhos em value (abaixo do bloco de código).

No segundo exemplo de código, o compilador conclui que o conteúdo do bloco de código da instrução if sempre será executado (true sempre é true). O compilador não gera um erro de build porque interpreta o segundo exemplo de código para ter um único caminho de execução conforme a seguir:

int value;
value = 10;
Console.WriteLine($"Inside the code block: {value}");
Console.WriteLine($"Outside the code block: {value}");

Recapitulação

Aqui estão algumas coisas importantes a serem lembradas sobre blocos de código:

Quando você declara uma variável dentro de um bloco de código, a visibilidade dela é local para esse bloco de código e essa variável não pode ser acessada fora do bloco de código.
Para garantir que uma variável esteja visível dentro e fora de um bloco de código, você deve declarar a variável antes do bloco de código (fora e acima do bloco de código).
Verifique se as variáveis são inicializadas antes que seu código tente acessá-las (para todos os caminhos de execução de código possíveis).

Comentários

Esta página foi útil?

Exercício – Blocos de código e escopo de variável

Verificar seu conhecimento

Comentários