0Pricing
C# Academy · Aula

public/internal/protected/private (com observação sobre file)

Aprenda como public, internal, protected e private alteram a visibilidade; veja as regras de herança e de mesmo assembly. Observe que o acesso limitado ao arquivo não existe no C# 6.

public/internal/protected/private (com observação sobre file) é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 3 aulas no total.

Visão geral dos modificadores de acesso

Objetivo: Escolha a visibilidade correta.

  • público: em qualquer lugar
  • internal: mesma compilação
  • protegido: classes derivadas
  • privado: mesma classe
  • arquivo: mais recente que C# 6 (apenas informativo)

Privado versus público

Mantenha os campos privados e exponha membros públicos validados.

using System;

// private: only inside the class; public: everywhere the class is visible
public class Box
{
  private int _width;             // hidden storage
  public int Width                // controlled access
  {
    get { return _width; }
    set { _width = value < 0 ? 0 : value; } // simple guard
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Box b = new Box();
    // b._width = -5; // INVALID: private (kept as comment)
    b.Width = 10;      // OK: public property
    Console.WriteLine("Width = " + b.Width);
  }
}

Protegido na herança

protegido é usado na herança: os tipos derivados podem acessá-lo, mas elementos externos não.

using System;

public class BaseCounter
{
  protected int Count; // derived classes can see this
  public int Value() { return Count; }
}

public class StepCounter : BaseCounter
{
  public void Step() { Count = Count + 1; } // allowed: protected
}

public class Program
{
  public static void Main(string[] args)
  {
    StepCounter sc = new StepCounter();
    sc.Step();
    // sc.Count = 5; // INVALID from outside (commented)
    Console.WriteLine("Value = " + sc.Value());
  }
}

Acesso internal

internal limita a visibilidade à compilação atual, seja de uma biblioteca ou de um aplicativo.

using System;

// internal type: visible only inside this assembly
internal class InternalHelper
{
  public static string Ping() { return "pong"; }
}

// public type can use internal from the same assembly
public class UsesInternal
{
  public string Call() { return InternalHelper.Ping(); }
}

public class Program
{
  public static void Main(string[] args)
  {
    UsesInternal u = new UsesInternal();
    Console.WriteLine(u.Call());
  }
}

Protegido internal

protegido internal significa: acessível por tipos derivados ou em qualquer lugar da mesma compilação.

using System;

public class LibraryBase
{
  // Accessible to derived types OR anywhere in the same assembly
  protected internal void Touch() { Console.WriteLine("touched"); }
}

public class LibChild : LibraryBase
{
  public void Use() { Touch(); } // via inheritance
}

public class Program
{
  public static void Main(string[] args)
  {
    LibChild c = new LibChild();
    c.Use();

    LibraryBase b = new LibraryBase();
    b.Touch(); // same assembly, allowed
  }
}

Observação sobre o modificador arquivo e dicas

Observação: o modificador de acesso arquivo surgiu em versões mais recentes do C# (não existe no C# 6). No C# 6, limite-se a público, internal, protegido, privado e protegido internal.

  • Prefira privado por padrão
  • Use público somente na superfície da API
  • Use internal para ocultar a implementação de outras compilações
  • Use protegido para a cooperação entre a base e os tipos derivados

Significado de internal

Verificação rápida: o que o modificador de acesso internal significa em C#?

Recapitulação

Recapitulação: Escolha a menor visibilidade necessária: privado → protegido/internal → público. O C# 6 não inclui o modificador mais recente arquivo; use internal para ocultação no nível da compilação.

Perguntas Frequentes

A aula “public/internal/protected/private (com observação sobre file)” é grátis?

Sim — o texto completo de “public/internal/protected/private (com observação sobre file)” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 3 aulas no total.

O que vou aprender em “public/internal/protected/private (com observação sobre file)”?

Aprenda como public, internal, protected e private alteram a visibilidade; veja as regras de herança e de mesmo assembly. Observe que o acesso limitado ao arquivo não existe no C# 6. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 3.

Quanto tempo leva a aula “public/internal/protected/private (com observação sobre file)”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. public/internal/protected/private (com observação sobre file)
  2. Namespaces, diretivas using e usings globais (observação)
  3. Tipos parciais e arquivos
← Voltar para C# Academy