Introducción a los modificadores de acceso en C #
Este artículo cubre el concepto más elemental de programación orientada a objetos desde la perspectiva del lenguaje de programación C #. El concepto se conoce como - Modificadores de acceso. La primera pregunta a responder es: ¿Qué son los modificadores de acceso? En pocas palabras, los modificadores de acceso controlan a qué objetos / variables / constantes / métodos (prácticamente todo) se puede acceder en qué parte del código. Los modificadores de acceso juegan un papel importante en la prueba del concepto de abstracción en la programación orientada a objetos. Controlan qué parte del programa debe ser y no debe ser visible para el usuario final. Por supuesto, un usuario final está menos preocupado por las constantes y variables involucradas en el algoritmo. Solo le preocupa qué método necesita invocar para obtener el resultado.
Tipos de modificadores de acceso en C #
C # nos proporciona cuatro tipos de modificadores de acceso:
- Privado (el modificador de acceso predeterminado, excepto enumeraciones e interfaces)
- Protegido (ligeramente restringido)
- Público (sin restricciones, la opción predeterminada para enumeraciones e interfaces)
- Interno (público dentro de la misma asamblea)
Además de estos cuatro modificadores de acceso, hay dos combinaciones más de nivel de acceso:
- Interno protegido
- Privado protegido
Comprendamos cada uno con un ejemplo.
1. Privado
Privado es el nivel de acceso más restringido. También es el modificador de acceso predeterminado para todas las constantes, variables, objetos definidos por el usuario, etc. Solo las enumeraciones e interfaces son públicas de forma predeterminada. Por lo tanto, si no especifica ningún modificador de acceso, C # le asigna el modificador predeterminado.
Los objetos privados no son accesibles fuera del cuerpo de la clase o estructura o sección de programa en la que se declaran. Cualquier intento de acceder al objeto fuera del alcance del cuerpo en el que se declara da como resultado un error en tiempo de compilación.
Ejemplo 1
using System;
class Employee //private by default
(
string name; //private by default
public string GetName()
(
return name;
)
public void SetName(string name)
(
this.name = name;
)
)
public class Program
(
public static void Main()
(
Employee emp = new Employee();
emp.SetName("John");
Console.Write("Employee name is " + emp.GetName());
// compile time error - 'Employee.name' is inaccessible due to its protection level
// Console.Write("Employee name is " + emp.name);
)
)
Salida 1:
Ejemplo # 2
using System;
public class Program
(
public static void Main()
(
int x = 5; //private to the Main method, accessible inside nested code blocks in the Main method
if (true)
(
int y = 10; //private to the if block, not accessible outside if block
Console.WriteLine("x = " + x);
Console.WriteLine("y = " + y);
)
Console.WriteLine("x = " + x);
// compile-time error - The name 'y' does not exist in the current context.
// Console.WriteLine("y = " + y);
)
)
Salida 2:
2. Protegido
El especificador de acceso protegido restringe que un objeto sea accesible solo desde instancias derivadas de la clase. Por lo tanto, si un objeto de clase secundaria intenta acceder a los objetos protegidos de una clase primaria, está permitido. Las clases no derivadas no pueden acceder a miembros protegidos de ninguna clase. Por supuesto, los objetos protegidos son accesibles a los métodos de la propia clase.
Ejemplo
using System;
class Parent
(
protected string x;
public Parent()
(
x = "abc"; //accessible to own class methods
)
)
class Child : Parent // derived class
(
public static void Main()
(
var parentObj = new Parent();
var childObj = new Child();
Console.WriteLine(childObj.x); //accessible to derived class object instances
// compile-time error - Cannot access protected member 'Parent.x' via a qualifier of type 'Parent'; the qualifier must be of type 'Child' (or derived from it)
// Console.WriteLine(parentObj.x);
)
)
Salida 3:
3. Público
Este es el modificador de acceso menos restringido. Los objetos públicos son prácticamente accesibles para todo el mundo exterior, lo que lo convierte en el modificador de acceso más alto permitido. Por supuesto, esto tiene un alto costo: el costo de la menor protección.
Se puede acceder a los miembros públicos desde cualquier parte del código. Esto los hace menos seguros. Cualquier lógica de código puede modificar su valor, lo que puede conducir a un comportamiento inesperado. Por lo tanto, uno debe ser muy cauteloso antes de hacer público cualquier objeto.
En la misma clase de empleado que creamos en nuestro ejemplo de modificador de acceso privado, si cambiamos el nivel de acceso al público no necesitaríamos ningún método Getter y Setter. De hecho, la mejor práctica es hacer que el objeto sea privado y usar las propiedades C # Getter y Setter.
Ejemplo
using System;
class Employee
(
public string name;
)
public class Program
(
public static void Main()
(
Employee emp = new Employee();
emp.name = "John";
Console.Write("Employee name is " + emp.name);
)
)
Salida 4:
4. Interno
Los objetos y métodos internos solo son accesibles dentro del mismo ensamblaje. Este es un modificador de acceso muy útil cuando desea hacer público cualquier objeto y, sin embargo, desea restringir su acceso solo al marco que está codificando.
Entonces, en esencia, todos los objetos internos son accesibles por todas las áreas del mismo ensamblaje.
Creemos dos aplicaciones de consola para entender este funcionamiento.
Ejemplo
Paso 1: cree una aplicación de consola de C # y coloque el siguiente código:
using System;
namespace ConsoleApp1
(
public class Parent
(
internal int x;
public Parent()
(
x = 10;
)
)
public class Program
(
public static void Main()
(
var parentObj = new Parent();
// accessible within the same assembly
Console.Write("The value of x = " + parentObj.x);
)
)
)
Paso 2: Cree la solución para obtener el archivo .dll de la carpeta bin.
Paso 3: Cree otra aplicación de consola y haga referencia al archivo de ensamblaje desde ConsoleApp1. Haga clic en Agregar referencia en la imagen a continuación y busque la ubicación del archivo .dll desde el paso 2. Debe ser similar a ~ / ConsoleApp1 / bin / Debug / ConsoleApp1.dll.
Después de agregar el archivo .dll, debería encontrarlo en Ensamblados.
Paso 4: coloque el siguiente código en ConsoleApp2.
using System;
using ConsoleApp1; //referencing the first assembly
namespace ConsoleApp2
(
class Program
(
static void Main(string() args)
(
var parentObj = new Parent();
//not accessible outside the assembly
Console.Write(parentObj.x);
)
)
)
Paso 5: cuando compila ConsoleApp2, recibirá un error en tiempo de compilación que indica que no se puede acceder a 'x' desde ConsoleApp1 en otros ensamblados debido a su nivel de protección.
5. Protegido interno
Esta es una combinación de modificadores de acceso tanto protegidos como internos. Un concepto importante para entender aquí es que Protegido interno significa protegido o interno. Es una unión de ambos modificadores de acceso. Nunca debe pensarse que es una intersección.
Por lo tanto, los objetos internos no son accesibles fuera del ensamblaje, mientras que los objetos protegidos son accesibles para cualquier clase derivada en cualquier ensamblaje. ¿Qué sucede si quiero proteger mi objeto solo en otros conjuntos y no en el mismo conjunto? Solución simple: declararlo como protegido interno.
Ejemplo
Paso 1: modifiquemos nuestra ConsoleApp1 para reflejar el código a continuación. Tenga en cuenta que hemos cambiado el nivel de acceso de nuestra variable 'x' a interno protegido.
using System;
namespace ConsoleApp1
(
public class Parent
(
protected internal int x;
public Parent()
(
x = 10;
)
)
public class Program
(
public static void Main()
(
var parentObj = new Parent();
// accessible within the same assembly
Console.Write("The value of x = " + parentObj.x);
)
)
)
Paso 2: Construya la solución nuevamente y reemplace el .dll en ConsoleApp2 con el actualizado.
Paso 3: Actualice el código en ConsoleApp2 como se muestra a continuación:
using System;
using ConsoleApp1; //referencing the first assembly
namespace ConsoleApp2
(
class Program: Parent
(
static void Main(string() args)
(
var progObj = new Program();
//accessible only via an object of the derived class.
Console.Write(progObj.x);
Console.Read();
)
)
)
Paso 4: Ejecute ConsoleApp2 para ver el resultado.
6. Privado protegido
Esta es una combinación de unión de modificadores de acceso tanto privados como protegidos. Protegido interno significa protegido o interno. Por lo tanto, los objetos privados no son accesibles fuera del bloque de código en el que se declara, mientras que los objetos protegidos son accesibles para cualquier clase derivada en cualquier ensamblaje. ¿Qué sucede si deseo restringir el acceso de mi objeto incluso en clases derivadas en otros ensamblados? Solución simple: declararlo como protegido interno.
Ejemplo
Modifiquemos el nivel de acceso de 'x' en ConsoleApp1 a Private Protected.
using System;
namespace ConsoleApp1
(
public class Parent
(
private protected int x;
public Parent()
(
x = 10;
)
)
public class Child: Parent (
public void DisplayX() (
// accessible only via derived class objects
Console.Write("Value of x = " + x);
)
)
public class Program
(
public static void Main()
(
var childObj = new Child();
childObj.DisplayX();
Console.Read();
)
)
)
Salida:
Comparación tabular
| Especificador de acceso | Misma asamblea | Otra Asamblea | |||
| Misma clase | Clase derivada | Clase no derivada | Clase derivada | Clase no derivada | |
| Privado | si | No | No | No | No |
| Público | si | si | si | si | si |
| Protegido | si | si | No | si | No |
| Interno | si | si | si | No | No |
| Interno protegido | si | si | si | si | No |
| Privado protegido | si | si | No | No | No |
Conclusión
Hemos visto en el artículo anterior que los modificadores de acceso controlan el acceso de todo en el proyecto. Varias combinaciones de niveles de acceso cubren las necesidades de varios tipos de accesibilidad. Los desarrolladores deben elegir sabiamente teniendo en cuenta la seguridad y la necesidad absoluta de que el objeto sea accesible en un determinado bloque de código.
Artículos recomendados
Esta es una guía de los modificadores de acceso en C #. Aquí hemos discutido los Tipos de introducción de modificadores de acceso en C # junto con ejemplos y resultados. También puede consultar nuestros otros artículos sugeridos para obtener más información:
- Compiladores de C #
- Destructor en C #
- ¿Qué es TypeScript?
- ¿Qué son los servicios web ASP.Net?
- Modificadores de acceso en PHP
- Métodos de trabajo y Top 3 Enum en C #