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 criar um sistema seguro de perfil de usuário que demonstra como os modificadores de acesso protegem dados confidenciais enquanto expõem apenas o que é necessário. Você criará uma classe na qual diferentes informações têm diferentes níveis de visibilidade, com base em quem deve poder acessá-las.

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

UserProfile.cs: crie uma classe UserProfile no namespace Security que gerencie as informações do usuário com níveis de acesso apropriados. O perfil deve ter:
- Uma propriedade public Username (string) - qualquer pessoa pode ver o nome de usuário
- Um campo private password (string) - somente a própria classe deve acessar este campo
- Um campo protected email (string) - a classe e suas classes derivadas podem acessá-lo
- 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 retorne "User: {Username}". Adicione outro método public chamado ValidatePassword(string input) que retorne true se a entrada corresponder à senha privada e false caso contrário.
AdminProfile.cs: crie uma classe AdminProfile no namespace Security que herde de UserProfile. Essa classe demonstra como membros protected se tornam acessíveis em classes derivadas. O construtor deve aceitar os mesmos quatro parâmetros e passá-los ao construtor da classe base. Adicione um método public chamado GetAdminInfo() que retorne "Admin: {Username}, Email: {email}" - observe que você pode acessar o campo email protegido 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 diretamente o campo interno (já que você está no mesmo assembly). Mostre quais informações cada tipo de usuário pode revelar.

Você receberá cinco entradas:

Nome de usuário
Senha
E-mail
ID do usuário (inteiro)
Tentativa de senha a ser validada

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 deverá 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, portanto somente o AdminProfile (uma classe derivada) pode expô-lo. O userId interno é acessível a partir do seu arquivo principal porque ele está no mesmo assembly. Isso é encapsulamento em açã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()
    }
}