Exercício – Chamar os métodos de uma classe .NET

12 minutos

Quer você tenha percebido ou não, você vem chamando métodos C# desde o seu primeiro aplicativo "Olá, Mundo!". Esse aplicativo usa o método WriteLine() da classe Console para exibir a mensagem "Olá, Mundo!".

No entanto, nem todas as classes e métodos são implementados da mesma maneira. Esta unidade aborda algumas das variantes mais comuns que você precisará entender ao usar métodos da biblioteca de classes do .NET. Mais importante, você aprenderá a localizar e usar a documentação para entender melhor o método.

Como chamar métodos na Biblioteca de Classes do .NET

Com base em sua experiência anterior com o método Console.WriteLine(), você já deve conhecer os conceitos básicos:

Comece digitando o nome da classe. Neste caso, o nome da classe é Console.
Adicione o operador de acesso de membro, o símbolo ..
Adicione o nome do método. Neste caso, o nome do método é WriteLine.
Adicione o operador de chamada do método, que é um conjunto de parênteses ().
Finalmente, especifique os argumentos que serão transmitidos ao método, se houver algum, entre os parênteses do operador de invocação de método. Aqui, você especifica o texto que deseja que o método Console.WriteLine() escreva no console (por exemplo, "Hello World!").

Opcionalmente, dependendo de como os desenvolvedores criaram e implementaram o método especificado, você também precisará:

Passar valores adicionais como parâmetros de entrada.
Aceitar um valor retornado.

Na próxima unidade, você examinará como transmitir valores de entrada para um método e como um método pode ser usado para retornar um valor para a rotina de chamada.

Embora alguns métodos possam ser chamados da mesma forma que você chamou Console.WriteLine(), há outros na biblioteca de classes do .NET que requerem uma abordagem diferente.

Preparar o ambiente de codificação

Este módulo inclui atividades de codificação que o orientam no processo de compilação e execução do código de exemplo. É recomendado 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 menu Arquivo do Visual Studio Code, selecione Abrir Pasta.
Na caixa de diálogo Abrir Pasta , navegue até a pasta Área de Trabalho do Windows.

Caso você tenha um local de pasta diferente onde mantém os projetos de código, você pode usar esse local de pasta. Neste treinamento, o importante é ter um local 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 menu Terminal do Visual Studio Code, 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 menu Arquivo do Visual Studio Code, 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.

Chame diferentes tipos de métodos na biblioteca de classes do .NET

No Editor do Visual Studio Code, para criar um exemplo de código que implemente métodos das classes System.Random e System.Console, insira o seguinte código:
```
Random dice = new Random();
int roll = dice.Next(1, 7);
Console.WriteLine(roll);
```
Este código simula um lançamento de dados usando o método Random.Next() para gerar um número e o método Console.WriteLine() para exibir o valor.

Observação

Você examinará o código em detalhes posteriormente nesta unidade.
No menu Arquivo do Visual Studio Code, clique em Salvar.
No modo de exibição EXPLORER, para abrir um Terminal no local da pasta TestProject, clique com o botão direito do mouse em TestProject e selecione Abrir no Terminal Integrado.

Observe que o painel “Terminal” inclui um prompt de comando que exibe um caminho de pasta. Por exemplo:
```
C:\Users\someuser\Desktop\CsharpProjects\TestProject>
```
Quando você usa o Terminal para executar comandos da CLI do .NET, os comandos são executados no local da pasta exibida. Verifique se a pasta de código corresponde ao caminho de pasta exibido no prompt de comando antes de criar ou executar o código.
No prompt de comando do Terminal, para executar o código, digite dotnet run e pressione Enter.

Observe que um número de 1 a 6 é exibido na saída do console (o número de pontos no dado). Se você executar o código em tempo suficiente, verá cada um dos números 1 a 6 exibidos.
Dedique alguns minutos ao exame da sintaxe usada para acessar os métodos Next() e WriteLine().

Observe que você usa técnicas diferentes para acessar os métodos.
```
Random dice = new Random();
int roll = dice.Next(1, 7);
Console.WriteLine(roll);
```
Na terceira linha de código, você inclui uma referência à classe Console e chama o método Console.WriteLine() diretamente. No entanto, você usa uma técnica diferente para chamar o método Random.Next(). A razão pela qual você está usando duas técnicas diferentes é porque alguns métodos são "com estado" e outros são "sem estado". Você examinará a diferença entre métodos com e sem estado na próxima seção.

Métodos com estado vs. sem estado

Em projetos de desenvolvimento de software, o termo estado é usado para descrever a condição do ambiente de execução em um momento específico no tempo. Conforme seu código executa linha por linha, os valores são armazenados em variáveis. A qualquer momento durante a execução, o estado atual do aplicativo é a coleção de todos os valores armazenados na memória.

Alguns métodos não dependem do estado atual do aplicativo para funcionarem corretamente. Em outras palavras, os métodos sem estado são implementados para que possam funcionar sem referenciar ou alterar os valores já armazenados na memória. Os métodos sem estado também são conhecidos como métodos estáticos.

Por exemplo, o método Console.WriteLine() não depende de nenhum valor armazenado na memória. Ele executa sua função e termina sem afetar o estado do aplicativo de qualquer forma.

Outros métodos, contudo, devem ter acesso ao estado do aplicativo para funcionar corretamente. Em outras palavras, os métodos com estado são construídos de maneira que os torna dependentes de valores armazenados na memória por linhas de código anteriores já executadas. Ou eles modificam o estado do aplicativo atualizando valores ou armazenando novos valores na memória. Eles também são conhecidos como métodos de instância.

Os métodos com estado (instância) controlam seu estado em campos, que são variáveis definidas na classe. Cada nova instância da classe tem sua própria cópia desses campos nos quais o estado é armazenado.

Uma única classe pode dar suporte a métodos com e sem estado. No entanto, quando você precisa chamar métodos com estado, deve primeiro criar uma instância da classe para que o método possa acessar o estado.

Criar uma instância de uma classe

Uma instância de uma classe é chamada como um objeto. Para criar uma instância de uma classe, use o operador new. Considere a seguinte linha de código que cria uma instância da classe Random para criar um objeto chamado dice:

Random dice = new Random();

O operador new faz várias coisas importantes:

Primeiro, ele solicita um endereço na memória do computador grande o suficiente para armazenar um novo objeto com base na classe Random.
Ele cria o objeto e o armazena no endereço de memória.
Retorna o endereço da memória para que possa ser salvo no objeto dice.

Desse ponto em diante, quando o objeto dice é referenciado no código, o .NET Runtime realiza uma pesquisa nos bastidores para dar a ilusão de que você está trabalhando diretamente com o próprio objeto.

Seu código usa o objeto dice como uma variável que armazena o estado da classe Random. Quando você chama o método Next() no objeto dice, o método usa o estado armazenado no objeto dice para gerar um número aleatório.

A versão mais recente do Runtime do .NET permite que você crie uma instância de um objeto sem ter que repetir o nome do tipo (invocação de construtor com tipo de destino). Por exemplo, o código a seguir criará uma nova instância da classe Random:

Random dice = new();

A intenção é simplificar a legibilidade do código. Você sempre usa parênteses ao escrever uma expressão new do tipo de destino.

Por que o método Next() é com estado?

Talvez você esteja se perguntando por que o método Next() foi implementado como um método com estado? Os designers da Biblioteca de Classes do .NET não conseguiram descobrir uma maneira de gerar um número aleatório sem exigir estado? E o que exatamente está sendo armazenado ou referenciado pelo método Next()?

Essas são perguntas justas. Em um alto nível, os computadores são bons em seguir instruções específicas para criar um resultado confiável e repetível. Para criar a ilusão de aleatoriedade, os desenvolvedores do método Next() decidiram capturar a data e hora até a fração de um milissegundo e usar isso para propagar um algoritmo que produz um número diferente a cada vez. Embora não seja totalmente aleatório, isso é suficiente para a maioria dos aplicativos. O estado capturado e mantido durante o tempo de vida do objeto dice é o valor inicial. Cada chamada subsequente ao método Next() está executando novamente o algoritmo, mas verifica se a semente é alterada para que o mesmo valor não seja (necessariamente) retornado.

No entanto, para usar o método Random.Next(), você não precisa entender como ele funciona. O importante é saber que alguns métodos exigem que você crie uma instância de uma classe antes de chamá-los, enquanto outros não.

Como é possível determinar se você precisa criar uma instância de uma classe ante de chamar seus métodos?

Uma abordagem para determinar se um método é um método com ou sem estado é consultar a documentação. A documentação inclui exemplos que mostram se ele deve ser chamado por meio da instância do objeto ou diretamente da classe.

Observação

Às vezes, você precisa rolar para baixo na página da documentação para encontrar os exemplos de código.

Como alternativa à pesquisa na documentação do produto, é possível tentar acessar o método diretamente por meio da própria classe. Se isso funcionar, você saberá que é um método sem estado. O pior que pode acontecer é você receber um erro de compilação.

Tente acessar o método Random.Next() diretamente e veja o que acontece.

Insira a seguinte linha de código no Editor do Visual Studio Code:
```
int result = Random.Next();
```
Você já sabe que Next() é um método com estado, no entanto, este exemplo demonstra como o Editor do Visual Studio Code reage quando você tenta acessar um método incorretamente.
Observe que uma linha ondulada vermelha aparece abaixo de Random.Next, indicando que há um erro de compilação.

Se você estiver interessado em usar um método sem estado, nenhuma linha ondulada vermelha aparecerá.
Passe o ponteiro do mouse sobre a linha ondulada vermelha.

Uma janela pop-up deve aparecer com a seguinte mensagem:
```
(1,14): error CS0120: An object reference is required for the non-static field, method, or property 'Random.Next()'
```
Como você viu no código do início da unidade, é possível corrigir esse erro criando uma instância da classe Random antes de acessar o método Next(). Por exemplo:
```
Random dice = new Random();
int roll = dice.Next();
```
Nesse caso, o método Next() é chamado sem parâmetros de entrada.

Recapitulação

Para chamar métodos de uma classe na Biblioteca de Classes do .NET, use o formato ClassName.MethodName(), em que o símbolo . é o operador de acesso de membro para acessar um método definido na classe e os símbolos () são os operadores de invocação de método.
Ao chamar um método sem estado, não é necessário criar uma instância de sua classe primeiro.
Ao chamar um método com estado, é necessário criar uma instância da classe e acessar o método no objeto.
Use o operador new para criar uma instância de uma classe.
Uma instância de uma classe é chamada como um objeto.

Comentários

Esta página foi útil?

Exercício – Chamar os métodos de uma classe .NET

Verifique seu conhecimento

Comentários