Modificadores de acceso en C#

Qué son

Los modificadores de acceso en C# definen dónde puede ser accedido un miembro (método, propiedad, campo o clase).
Sirven para controlar la visibilidad y proteger la encapsulación del código.

---

🔒 1️⃣ private

📘 Definición:
El miembro solo es accesible dentro de la misma clase o struct.

📍Uso común: para ocultar detalles internos que no deben ser accedidos directamente.

public class Persona
{
    private string nombre; // solo visible dentro de Persona

    private void MostrarInterno()
    {
        Console.WriteLine("Método privado");
    }

    public void Mostrar()
    {
        // Aquí sí puedo usar el campo y método privados
        nombre = "Grover";
        MostrarInterno();
    }
}

❌ No se puede acceder desde fuera:

var p = new Persona();
// p.nombre = "Grover";        // ❌ Error
// p.MostrarInterno();         // ❌ Error
p.Mostrar();                  // ✅ OK

---

🌐 2️⃣ public

📘 Definición:
El miembro es accesible desde cualquier parte del programa, incluso desde otros ensamblados (proyectos).

📍Uso común: para exponer clases o métodos que deben ser utilizados por otros componentes o capas.

public class Persona
{
    public string Nombre { get; set; }

    public void Saludar()
    {
        Console.WriteLine($"Hola, soy {Nombre}");
    }
}

✔️ Se puede usar libremente:

var p = new Persona();
p.Nombre = "Grover";
p.Saludar();

---

🏠 3️⃣ internal

📘 Definición:
El miembro o clase solo es accesible dentro del mismo ensamblado (assembly),
es decir, dentro del mismo proyecto .dll o .exe.

📍Uso común: cuando quieres compartir funcionalidad solo dentro del mismo proyecto, pero ocultarla a otros ensamblados.

internal class RepositorioInterno
{
    internal void Conectar()
    {
        Console.WriteLine("Conectando base de datos interna...");
    }
}

✔️ Dentro del mismo proyecto:

var repo = new RepositorioInterno(); // ✅ OK
repo.Conectar();

❌ Desde otro ensamblado (otra DLL o proyecto):

var repo = new RepositorioInterno(); // ❌ Error: no accesible

---

🧬 4️⃣ protected

📘 Definición:
El miembro solo es accesible dentro de la clase base o en clases derivadas (herencia).

📍Uso común: cuando una subclase necesita usar un miembro, pero no quieres que sea público.

public class Persona
{
    protected string Nombre { get; set; } = "";

    protected void Hablar()
    {
        Console.WriteLine("Soy una persona.");
    }
}

public class Estudiante : Persona
{
    public void Presentarse()
    {
        Nombre = "Grover";  // ✅ permitido (por herencia)
        Hablar();           // ✅ permitido
        Console.WriteLine($"Hola, soy {Nombre}");
    }
}

❌ Desde fuera:

var e = new Estudiante();
// e.Nombre = "Juan";   // ❌ Error
// e.Hablar();          // ❌ Error
e.Presentarse();         // ✅ OK

---

🧠 Comparativa rápida

Modificador	Accesible dentro de la clase	En clases derivadas	En el mismo ensamblado	En otros ensamblados
private	✅ Sí	❌ No	❌ No	❌ No
protected	✅ Sí	✅ Sí	❌ No	❌ No
internal	✅ Sí	✅ (si están en el mismo assembly)	✅ Sí	❌ No
public	✅ Sí	✅ Sí	✅ Sí	✅ Sí

---

🧩 Combinaciones útiles

También existen combinaciones de modificadores:

Combinación	Significado
protected internal	Accesible desde clases derivadas y desde cualquier código dentro del mismo ensamblado.
private protected	Accesible solo desde clases derivadas que estén dentro del mismo ensamblado.

Ejemplo:

protected internal void MetodoCompartido() { }
private protected void MetodoInternoDerivado() { }