Modificadores de acceso en C#

Los modificadores de acceso son palabras clave que definen la accesibilidad de un miembro, clase o tipo de datos en un programa. Estos se utilizan principalmente para restringir la manipulación de datos no deseados por parte de programas o clases externos. Hay 4 modificadores de acceso (público, protegido, interno, privado) que definen los 6 niveles de accesibilidad de la siguiente manera:

La tabla de accesibilidad de estos modificadores se muestra a continuación:

Nivel de accesibilidad pública

Se concede acceso a todo el programa. Esto significa que otro método u otro ensamblado que contiene la referencia de clase puede acceder a estos miembros o tipos. Este modificador de acceso tiene el nivel de acceso más permisivo en comparación con todos los demás modificadores de acceso.
Sintaxis:
 

public TypeName

Ejemplo: aquí, declaramos una clase Student que consta de dos miembros de la clase rollNo y name que son públicos. Estos miembros pueden acceder desde cualquier parte del código en el ensamblado actual y otro en el programa. Los métodos getRollNo y getName también se declaran como públicos.
 

// C# Program to show the use of
// public Access Modifier
using System;
 
namespace publicAccessModifier {
 
class Student {
 
    // Declaring members rollNo
    // and name as public
    public int rollNo;
    public string name;
 
    // Constructor
    public Student(int r, string n)
    {
        rollNo = r;
        name = n;
    }
 
    // methods getRollNo and getName
    // also declared as public
    public int getRollNo()
    {
        return rollNo;
    }
    public string getName()
    {
        return name;
    }
}
 
class Program {
   
    // Main Method
    static void Main(string[] args)
    {
        // Creating object of the class Student
        Student S = new Student(1, "Astrid");
 
        // Displaying details directly
        // using the class members
        // accessible through another method
        Console.WriteLine("Roll number: {0}", S.rollNo);
        Console.WriteLine("Name: {0}", S.name);
 
        Console.WriteLine();
 
        // Displaying details using
        // member method also public
        Console.WriteLine("Roll number: {0}", S.getRollNo());
        Console.WriteLine("Name: {0}", S.getName());
    }
}
}

Roll number: 1
Name: Astrid

Roll number: 1
Name: Astrid

Nivel de accesibilidad protegido

El acceso está limitado a la clase que contiene el miembro y los tipos derivados de esta clase. Significa que una clase que es la subclase de la clase contenedora en cualquier parte del programa puede acceder a los miembros protegidos.
Sintaxis: 
 

protected TypeName

Ejemplo: en el código que se muestra a continuación, la clase Y hereda de X, por lo tanto, se puede acceder a cualquier miembro protegido de X desde Y, pero los valores no se pueden modificar.
 

// C# Program to show the use of
// protected Access Modifier
using System;
 
namespace protectedAccessModifier {
 
class X {
 
    // Member x declared
    // as protected
    protected int x;
 
    public X()
    {
        x = 10;
    }
}
 
// class Y inherits the
// class X
class Y : X {
 
    // Members of Y can access 'x'
    public int getX()
    {
        return x;
    }
}
 
class Program {
 
    static void Main(string[] args)
    {
        X obj1 = new X();
        Y obj2 = new Y();
 
        // Displaying the value of x
        Console.WriteLine("Value of x is : {0}", obj2.getX());
    }
}
}

Value of x is : 10

Nivel de accesibilidad interna

El acceso está limitado solo al ensamblaje actual, es decir, cualquier clase o tipo declarado como interno es accesible en cualquier lugar dentro del mismo espacio de nombres. Es el modificador de acceso predeterminado en C# .
Sintaxis:
 

internal TypeName

Ejemplo: en el código que se proporciona a continuación, la clase Complex forma parte del espacio de nombres internalAccessModifier y es accesible a través de él.
 

// C# Program to show use of
// internal access modifier
// Inside the file Program.cs
using System;
 
namespace internalAccessModifier {
 
// Declare class Complex as internal
internal class Complex {
 
    int real;
    int img;
 
    public void setData(int r, int i)
    {
        real = r;
        img = i;
    }
 
    public void displayData()
    {
        Console.WriteLine("Real = {0}", real);
        Console.WriteLine("Imaginary = {0}", img);
    }
}
 
// Driver Class
class Program {
 
    // Main Method
    static void Main(string[] args)
    {
        // Instantiate the class Complex
        // in separate class but within
        // the same assembly
        Complex c = new Complex();
 
        // Accessible in class Program
        c.setData(2, 1);
        c.displayData();
    }
}
}

Real = 2
Imaginary = 1

Nota: en el mismo código, si agrega otro archivo, la clase Complex no estará accesible en ese espacio de nombres y el compilador arrojará un error.
 

// C# program inside file xyz.cs
// separate nampespace named xyz
using System;
 
namespace xyz {
 
class text {
 
    // Will give an error during compilation
    Complex c1 = new Complex();
    c1.setData(2, 3);
}
}

error CS1519

Nivel de accesibilidad interno protegido

El acceso está limitado al ensamblado actual o a los tipos derivados de la clase contenedora. Significa que se otorga acceso a cualquier clase que se derive de la clase contenedora dentro o fuera del ensamblado actual.
Sintaxis:
 

protected internal TypeName

Ejemplo: en el código que se muestra a continuación, el miembro ‘ valor ‘ se declara como protegido interno, por lo tanto, es accesible en toda la clase Padre y también en cualquier otra clase en el mismo ensamblaje como ABC . También se puede acceder a ella dentro de otra clase derivada de Parent , a saber, Child , que está dentro de otro ensamblado.
 

// Inside file parent.cs
using System;
 
public class Parent {
 
    // Declaring member as protected internal
    protected internal int value;
}
 
class ABC {
 
    // Trying to access
    // value in another class
    public void testAccess()
    {
        // Member value is Accessible
        Parent obj1 = new Parent();
        obj1.value = 12;
    }
}

// Inside file GFg.cs
using System;
 
namespace GFG {
 
class Child : Parent {
 
    // Main Method
    public static void Main(String[] args)
    {
        // Accessing value in another assembly
        Child obj3 = new Child();
 
        // Member value is Accessible
        obj3.value = 9;
        Console.WriteLine("Value = " + obj3.value);
    }
}
}

Value = 9

Nivel de accesibilidad privado

El acceso solo se otorga a la clase contenedora. Cualquier otra clase dentro del ensamblaje actual o de otro no tiene acceso a estos miembros.
Sintaxis:
 

private TypeName

Ejemplo: en este código declaramos el valor del miembro de la clase Parent como privado, por lo tanto, su acceso está restringido solo a la clase que lo contiene. Intentamos acceder al valor dentro de una clase derivada llamada Child , pero el compilador arroja un error {error CS0122: ‘PrivateAccessModifier.Parent.value’ es inaccesible debido a su nivel de protección}. De manera similar, dentro de main {que es un método en otra clase}. obj.value arrojará el error anterior. Entonces podemos usar métodos de miembros públicos que pueden establecer u obtener valores de miembros privados.
 

// C# Program to show use of
// the private access modifier
using System;
 
namespace PrivateAccessModifier {
 
class Parent {
 
    // Member is declared as private
    private int value;
 
    // value is Accessible
    // only inside the class
    public void setValue(int v)
    {
        value = v;
    }
 
    public int getValue()
    {
        return value;
    }
}
class Child : Parent {
 
    public void showValue()
    {
        // Trying to access value
        // Inside a derived class
        // Console.WriteLine( "Value = " + value );
        // Gives an error
    }
}
 
// Driver Class
class Program {
 
    static void Main(string[] args)
    {
        Parent obj = new Parent();
 
        // obj.value = 5;
        // Also gives an error
 
        // Use public functions to assign
        // and use value of the member 'value'
        obj.setValue(4);
        Console.WriteLine("Value = " + obj.getValue());
    }
}
}

Value = 4

Nivel de accesibilidad protegido privado

Se otorga acceso a la clase contenedora y sus tipos derivados presentes en el ensamblado actual. Este modificador es válido en C# versión 7.2 y posteriores.
Sintaxis:
 

private protected TypeName

Ejemplo: este código es el mismo que el código anterior, pero dado que el modificador de acceso para el valor del miembro es «protegido de forma privada», ahora se puede acceder a él dentro de la clase derivada o padre, es decir, hijo. Cualquier clase derivada que pueda estar presente en otro ensamblado no podrá acceder a estos miembros privados protegidos.
 

// C# Program to show use of
// the private protected
// Accessibility Level
using System;
 
namespace PrivateProtectedAccessModifier {
 
class Parent {
 
    // Member is declared as private protected
    private protected int value;
 
    // value is Accessible only inside the class
    public void setValue(int v)
    {
        value = v;
    }
    public int getValue()
    {
        return value;
    }
}
 
class Child : Parent {
 
    public void showValue()
    {
        // Trying to access value
        // Inside a derived class
 
        Console.WriteLine("Value = " + value);
        // value is accessible
    }
}
 
// Driver Code
class Program {
 
    // Main Method
    static void Main(string[] args)
    {
        Parent obj = new Parent();
 
        // obj.value = 5;
        // Also gives an error
 
        // Use public functions to assign
        // and use value of the member 'value'
        obj.setValue(4);
        Console.WriteLine("Value = " + obj.getValue());
    }
}
}

Value = 4

Puntos importantes:
 

• Los espacios de nombres no permiten los modificadores de acceso ya que no tienen restricciones de acceso.
• El usuario puede usar solo una accesibilidad a la vez, excepto la privada protegida y la interna protegida .
• La accesibilidad predeterminada para los tipos de nivel superior (que no están anidados en otros tipos, solo pueden tener accesibilidad pública o interna) es interna.
• Si no se especifica ningún modificador de acceso para una declaración de miembro, se usa la accesibilidad predeterminada según el contexto.