Entendiendo los modificadores de acceso en C#: Public, Private, Protected, Internal y más

Entendiendo los modificadores de acceso en C#

Esta guía explica cómo los diversos modificadores de acceso en C# —public, private, protected, internal, protected internal y private protected— controlan la visibilidad de tipos y miembros. Ejemplos de código reales ilustran el efecto de cada modificador.

En C#, los modificadores de acceso determinan quién puede leer o escribir campos, llamar métodos o instanciar tipos. Por ejemplo:

class Student {
    public string name;
    private int num;
}

Aquí, name es visible en todas partes, mientras que num está confinado a la clase Student.

Tipos de modificadores de acceso

• public
• private
• protected
• internal
• protected internal
• private protected

---

1. Modificador de acceso Public

Marcar un tipo o miembro como public lo hace accesible desde cualquier código que pueda referenciar el ensamblado.

using System;
namespace MyApplication {
    class Student {
        public string name = "Sheeran";
        public void Print() {
            Console.WriteLine("Hello from Student class");
        }
    }
    class Program {
        static void Main(string[] args) {
            Student student1 = new Student();
            Console.WriteLine("Name: " + student1.name);
            student1.Print();
            Console.ReadLine();
        }
    }
}

Salida

Name: Sheeran
Hello from Student class

Como tanto el campo como el método son public, la clase Program puede acceder a ellos libremente.

Consejo: El objeto student1 se usa para acceder a los miembros de Student. Aprende más sobre Clases y objetos en C#.

---

2. Modificador de acceso Private

Un miembro private es visible solo dentro de su class o struct declarante. El código externo, al intentar acceder, produce errores en tiempo de compilación.

using System;
namespace MyApplication {
    class Student {
        private string name = "Sheeran";
        private void Print() {
            Console.WriteLine("Hello from Student class");
        }
    }
    class Program {
        static void Main(string[] args) {
            Student student1 = new Student();
            Console.WriteLine("Name: " + student1.name);
            student1.Print();
            Console.ReadLine();
        }
    }
}

Intentar acceder a name o Print desde Program resulta en:

CS0122 'Student.name' is inaccessible due to its protection level
CS0122 'Student.Print()' is inaccessible due to its protection level

---

3. Modificador de acceso Protected

Los miembros marcados protected son accesibles dentro de su propia clase y cualquier clase derivada, independientemente del ensamblado.

using System;
namespace MyApplication {
    class Student {
        protected string name = "Sheeran";
    }
    class Program : Student {
        static void Main(string[] args) {
            Program program = new Program();
            Console.WriteLine("Name: " + program.name);
            Console.ReadLine();
        }
    }
}

Salida

Name: Sheeran

Aquí, Program hereda de Student, permitiéndole acceder al campo protegido name.

---

4. Modificador de acceso Internal

Un miembro internal es visible solo dentro del mismo ensamblado —una unidad lógica de código compilado. Los ensamblados se crean por el compilador al construir un proyecto.

Dentro de un solo ensamblado:

using System;
namespace Assembly {
    class Student {
        internal string name = "Sheeran";
    }
    class Program {
        static void Main(string[] args) {
            Student theStudent = new Student();
            Console.WriteLine("Name: " + theStudent.name);
            Console.ReadLine();
        }
    }
}

Salida

Name: Sheeran

Cuando el mismo ensamblado intenta acceder al campo, se comporta como public porque los miembros internal se comparten en todo el ensamblado.

En un ensamblado diferente, el campo es inaccesible:

// Assembly1
using System;
namespace Assembly1 {
    public class StudentName {
        internal string name = "Sheeran";
    }
}
// Assembly2
using System;
using Assembly1;
namespace Assembly2 {
    class Program {
        static void Main(string[] args) {
            StudentName student = new StudentName();
            Console.Write(student.name); // CS0122
            Console.ReadLine();
        }
    }
}

Intentar compilar Assembly2 produce:

CS0122 'StudentName.name' is inaccessible due to its protection level

---

5. Modificador de acceso Protected Internal

La combinación protected internal permite acceso desde el mismo ensamblado o desde tipos derivados en otros ensamblados.

// Assembly1
using System;
namespace Assembly1 {
    public class Greet {
        protected internal string msg = "Hello";
    }
}
// Assembly2
using System;
using Assembly1;
namespace Assembly2 {
    class Program : Greet {
        static void Main(string[] args) {
            Program greet = new Program();
            Console.Write(greet.msg);
            Console.ReadLine();
        }
    }
}

Salida

Hello

---

6. Modificador de acceso Private Protected

Introducido en C# 7.2, private protected restringe la visibilidad a la clase declarante y sus clases derivadas dentro del mismo ensamblado.

// Assembly1
using System;
namespace Assembly1 {
    public class StudentName {
        private protected string name = "Sheeran";
    }
    class Program1 : StudentName {
        static void Main(string[] args) {
            Program1 student = new Program1();
            Console.Write(student.name);
            Console.ReadLine();
        }
    }
}
// Assembly2
using System;
using Assembly1;
namespace Assembly2 {
    class Program : StudentName {
        static void Main(string[] args) {
            Program student = new Program();
            Console.Write(student.name); // CS0122
            Console.ReadLine();
        }
    }
}

El acceso desde Assembly2 falla porque el miembro no se expone más allá de su ensamblado, incluso en tipos derivados.

Nota: Mientras que los tipos (clases, interfaces, etc.) pueden usar public y internal, todos los demás modificadores aplican solo a miembros.