Modificadores de Acesso

Parte da seção Programação Orientada a Objetos do Journey de C# da Coddy — lição 31 de 70.

Modificadores de acesso controlam quem pode ver e usar os membros da sua classe. Eles são a base do encapsulamento - um dos princípios fundamentais da OOP. Ao restringir o acesso, você protege seus dados e cria limites claros em seu código.

O C# fornece quatro modificadores de acesso principais:

public class BankAccount
{
    public string AccountHolder;      // Acessível de qualquer lugar
    private decimal balance;          // Apenas dentro desta classe
    protected string accountType;     // Esta classe e classes derivadas
    internal int branchCode;          // Dentro do mesmo assembly
}

Membros public são acessíveis a partir de qualquer código.

Membros private só podem ser acessados dentro da mesma classe - este é o mais restritivo e o padrão para membros de classe.

protected permite o acesso a partir da própria classe e de qualquer classe que herde dela.

internal restringe o acesso ao código dentro do mesmo assembly (projeto).

Quando nenhum modificador é especificado, os membros da classe são private por padrão:

class Example
{
    int secret;  // private por padrão
}

Escolher o nível de acesso correto trata-se de expor apenas o que é necessário. Comece com private e aumente a visibilidade apenas quando tiver um motivo claro. Isso evita que outros códigos dependam de detalhes de implementação que você pode querer alterar mais tarde.

Desafio

Fácil

Vamos construir um sistema de perfil de usuário seguro que demonstra como os modificadores de acesso protegem dados sensíveis enquanto expõem apenas o que é necessário. Você criará uma classe onde diferentes informações possuem diferentes níveis de visibilidade com base em quem deve ter permissão para acessá-las.

Você organizará seu código em três arquivos:

UserProfile.cs: Crie uma classe UserProfile no namespace Security que gerencia informações de usuário com níveis de acesso apropriados. O perfil deve ter:
- Uma propriedade public Username (string) - qualquer um pode ver o nome de usuário
- Um campo private password (string) - apenas a própria classe deve acessar isso
- Um campo protected email (string) - a classe e seus filhos podem acessar isso
- Um campo internal userId (int) - acessível dentro do mesmo assembly
Inclua um construtor que aceite username, password, email e userId. Adicione um método public chamado GetPublicInfo() que retorna "User: {Username}". Adicione outro método public chamado ValidatePassword(string input) que retorna true se a entrada corresponder à senha privada, false caso contrário.
AdminProfile.cs: Crie uma classe AdminProfile no namespace Security que herda de UserProfile. Esta classe demonstra como membros protected tornam-se acessíveis em classes derivadas. O construtor deve aceitar os mesmos quatro parâmetros e passá-los para o construtor base. Adicione um método public chamado GetAdminInfo() que retorna "Admin: {Username}, Email: {email}" - observe que você pode acessar o campo protegido email aqui!
Program.cs: No seu arquivo principal, crie um UserProfile e um AdminProfile usando valores de entrada. Demonstre os níveis de acesso chamando os métodos públicos disponíveis e acessando o campo interno diretamente (já que você está no mesmo assembly). Mostre quais informações cada tipo de usuário pode revelar.

Você receberá cinco entradas:

Username
Password
Email
User ID (inteiro)
Tentativa de senha para validar

Imprima a saída neste formato:

Regular User:
{GetPublicInfo() result}
Internal ID: {userId}
Password valid: {ValidatePassword result}
Admin User:
{GetAdminInfo() result}

Por exemplo, se as entradas forem alice, secret123, alice@email.com, 1001 e secret123, a saída deve ser:

Regular User:
User: alice
Internal ID: 1001
Password valid: True
Admin User:
Admin: alice, Email: alice@email.com

Observe como a senha permanece completamente oculta - você só pode validá-la, nunca recuperá-la. O e-mail é protegido, então apenas o AdminProfile (uma classe derivada) pode expô-lo. O userId interno é acessível a partir do seu arquivo principal porque está no mesmo assembly. Isso é o encapsulamento em ação!

Folha de consulta

Modificadores de acesso controlam a visibilidade e a acessibilidade dos membros da classe, formando a base do encapsulamento em POO.

O C# fornece quatro modificadores de acesso principais:

public class BankAccount
{
    public string AccountHolder;      // Acessível de qualquer lugar
    private decimal balance;          // Apenas dentro desta classe
    protected string accountType;     // Esta classe e classes derivadas
    internal int branchCode;          // Dentro do mesmo assembly
}

public: acessível a partir de qualquer código

private: acessível apenas dentro da mesma classe (o mais restritivo, padrão para membros de classe)

protected: acessível a partir da própria classe e de quaisquer classes derivadas

internal: acessível apenas dentro do mesmo assembly (projeto)

Quando nenhum modificador é especificado, os membros da classe assumem o padrão private:

class Example
{
    int secret;  // private por padrão
}

Melhor prática: comece com private e aumente a visibilidade apenas quando necessário para evitar que o código externo dependa de detalhes de implementação.

Experimente você mesmo

using System;
using Security;

class Program
{
    public static void Main(string[] args)
    {
        // Ler entradas
        string username = Console.ReadLine();
        string password = Console.ReadLine();
        string email = Console.ReadLine();
        int userId = Convert.ToInt32(Console.ReadLine());
        string passwordAttempt = Console.ReadLine();

        // TODO: Criar um objeto UserProfile com os valores de entrada

        // TODO: Criar um objeto AdminProfile com os mesmos valores de entrada

        // TODO: Imprimir "Regular User:"

        // TODO: Imprimir o resultado de GetPublicInfo()

        // TODO: Imprimir "Internal ID: " seguido pelo campo userId (acessível por estar no mesmo assembly)

        // TODO: Imprimir "Password valid: " seguido pelo resultado de ValidatePassword()

        // TODO: Imprimir "Admin User:"

        // TODO: Imprimir o resultado de GetAdminInfo()
    }
}