Modificadores de acceso de C#

Modificadores de acceso C#

En este tutorial, aprenderemos sobre los modificadores de acceso público, privado, protegido e interno en C# con la ayuda de ejemplos.

En C#, los modificadores de acceso especifican la accesibilidad de tipos (clases, interfaces, etc.) y miembros de tipos (campos, métodos, etc.). Por ejemplo,

class Student {

  public string name;
    
  private int num;

  }

Aquí,

nombre - campo público al que se puede acceder desde cualquier lugar
numero - solo se puede acceder al campo privado dentro del Estudiante clase

Tipos de modificadores de acceso

En C#, hay 4 tipos básicos de modificadores de acceso.

público
privado
protegido
interno

1. modificador de acceso público

Cuando declaramos un tipo o miembro de tipo public , se puede acceder desde cualquier lugar. Por ejemplo,

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) {
    
      // creating object of Student class
      Student student1 = new Student();
      
      // accessing name field and printing it
      Console.WriteLine("Name: " + student1.name);

      // accessing print method from Student
      student1.print();
      Console.ReadLine();
    }
  }
}

Salida

Name: Sheeran
Hello from Student class

En el ejemplo anterior, hemos creado una clase llamada Estudiante con un campo nombre y un método print() .

// accessing name field and printing it
Console.WriteLine("Name: " + student1.name);

// accessing print method from Student
student1.print();

Dado que el campo y el método son públicos, podemos acceder a ellos desde el Programa clase.

Nota :Hemos utilizado el objeto estudiante1 del Estudiante clase para acceder a sus miembros. Para obtener más información, visite la clase y objetos de C# .

2. modificador de acceso privado

Cuando declaramos un miembro de tipo con el private modificador de acceso, solo se puede acceder dentro del mismo class o struct . Por ejemplo,

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) {
    
      // creating object of Student class
      Student student1 = new Student();
      
      // accessing name field and printing it
      Console.WriteLine("Name: " + student1.name);

      // accessing print method from Student
      student1.print();

      Console.ReadLine();
    }
  }
}

En el ejemplo anterior, hemos creado una clase llamada Estudiante con un campo nombre y un método print() .

// accessing name field and printing it
Console.WriteLine("Name: " + student1.name);

// accessing print method from Student
student1.print();

Dado que el campo y el método son privados, no podemos acceder a ellos desde el Programa clase. Aquí, el código generará el siguiente error.

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

3. modificador de acceso protegido

Cuando declaramos un miembro de tipo como protected , solo se puede acceder desde la misma clase y sus clases derivadas. Por ejemplo,

using System;

namespace MyApplication {

  class Student {
    protected string name = "Sheeran";
  }

  class Program {
    static void Main(string[] args) {
    
      // creating object of student class
      Student student1 = new Student();
      
      // accessing name field and printing it
      Console.WriteLine("Name: " + student1.name);
      Console.ReadLine();
    }
  }
}

En el ejemplo anterior, hemos creado una clase llamada Estudiante con un campo nombre . Dado que el campo está protegido, no podemos acceder a él desde el Programa clase.

Aquí, el código generará el siguiente error.

Error    CS0122    'Student.name' is inaccessible due to its protection level

Ahora, intentemos acceder al protected miembro de una clase derivada.

using System;

namespace MyApplication {

  class Student {
    protected string name = "Sheeran";
  }
  
  // derived class
  class Program : Student {
    static void Main(string[] args) {

      // creating object of derived class
      Program program = new Program();
      
      // accessing name field and printing it
      Console.WriteLine("Name: " + program.name);
      Console.ReadLine();
    }
  }
}

Salida

Name: Sheeran

En el ejemplo anterior, hemos creado una clase Estudiante con un campo protegido nombre . Note que hemos heredado el Program clase del Estudiante clase.

// accessing name field and printing it
Console.WriteLine("Name: " + program.name);

Desde el protected se puede acceder al miembro desde clases derivadas, podemos acceder a name del Programa clase.

4. modificador de acceso interno

Cuando declaramos un tipo o miembro de tipo como internal , solo se puede acceder a él dentro del mismo ensamblado.

Un ensamblaje es una colección de tipos (clases, interfaces, etc.) y recursos (datos). Están diseñados para trabajar juntos y formar una unidad lógica de funcionalidad.

Es por eso que cuando ejecutamos un ensamblaje, todas las clases e interfaces dentro del ensamblaje se ejecutan juntas. Para obtener más información, visite el ensamblado de C#.

Ejemplo:interno dentro del mismo ensamblaje

using System;

namespace Assembly {

  class Student {
   internal string name = "Sheeran";
  }

  class Program {
    static void Main(string[] args) {
    
      // creating object of Student class
      Student theStudent = new Student();
      
      // accessing name field and printing it
      Console.WriteLine("Name: " + theStudent.name);
      Console.ReadLine();
    }
  }
}

Salida

Name: Sheeran

En el ejemplo anterior, hemos creado una clase llamada Estudiante con un campo nombre . Dado que el campo es internal , podemos acceder desde el Programa clase ya que están en el mismo ensamblado.

Si usamos internal dentro de un solo ensamblaje, funciona como el public modificador de acceso.

Ejemplo:interno en ensamblaje diferente

Primero creemos un conjunto.

// Code on Assembly1
using System;

namespace Assembly1 {

  public class StudentName {
    internal string name = "Sheeran";
  }

  class Program {
    static void Main(string[] args) {
    }
  }
}

Aquí, este código está en Asamblea1 . Hemos creado un campo interno nombre dentro de la clase NombreEstudiante . Ahora, solo se puede acceder a este campo desde el mismo ensamblaje Asamblea1 .

Ahora, creemos otro ensamblaje.

// Code on Assembly2
using System;

// access Assembly1
using Assembly1;

namespace Assembly2 {
  class Program {
    static void Main(string[] args) {
      StudentName student = new StudentName();

      // accessing name field from Assembly1
      Console.Write(student.name);
      Console.ReadLine();
     }
  }
}

Aquí, este código está en Assembly2 . Estamos tratando de acceder al nombre campo del NombreEstudiante clase(Ensamblaje1 ).

Para acceder a campos desde Asamblea1 , primero debemos establecer la referencia de Asamblea1 en Asamblea2 . Ahora el código

using Assembly1;

nos permite usar el código de Assembly1 a Ensamblaje2 .

Aquí, cuando intentamos acceder al nombre campo de Asamblea2 , obtenemos un error.

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

Esto se debe a que nombre es un campo interno presente en Assembly1 .

5. modificador de acceso interno protegido

El protected internal es una combinación de protected y internal modificadores de acceso.

Cuando declaramos un miembro protected internal , se puede acceder desde el mismo ensamblado y la clase derivada de la clase contenedora desde cualquier otro ensamblado.

// Code on Assembly1
using System;

namespace Assembly1 {
  public class Greet {
    protected internal string msg="Hello";
  }

  class Program {
    static void Main(string[] args) {
      Greet greet = new Greet();
      Console.WriteLine(greet.msg);
      Console.ReadLine();
     }
  }
}

Salida

Hello

El código anterior está en Asamblea1 .

En el ejemplo anterior, hemos creado una clase llamada Greet con un campo mensaje . Dado que el campo está protegido internamente, podemos acceder a él desde el Programa clase ya que están en el mismo ensamblado.

Derivamos una clase de Greet en otro ensamblaje e intente acceder al campo interno protegido msg de ella.

// Code on Assembly2
using System;

// access Assembly1
using Assembly1;

namespace Assembly2 {

  // derived class of Greet
  class Program: Greet {
    static void Main(string[] args) {
      Program greet = new Program();

      // accessing name field from Assembly1
      Console.Write(greet.msg);
      Console.ReadLine();
    }
  }
}

Salida

Hello

El código anterior está en Assembly2 .

En el ejemplo anterior, hemos heredado el Program clase del Saludo clase (de Asamblea1 ).

// accessing name field from Assembly1
Console.Write(greet.msg);

Podemos acceder al msg del Saludo clase de Asamblea1 de Asamblea2 .

Esto se debe a que el msg es un campo interno protegido y estamos intentando acceder a él desde la clase secundaria de Greet .

6. modificador de acceso privado protegido

El private protected modificador de acceso es una combinación de private y protected . Está disponible desde la versión 7.2 de C# y posteriores.

Cuando declaramos un miembro private protected , solo se puede acceder dentro de la misma clase y su clase derivada dentro del mismo ensamblado. Por ejemplo,

// Code in Assembly1
using System;

namespace Assembly1 {
  public class StudentName {
    private protected string name = "Sheeran";
  }

  //derived class of StudentName class
  class Program1 : StudentName {

    static void Main(string[] args) {

      Program1 student = new Program1();

      //  accessing name field from base class
      Console.Write(student.name);
      Console.ReadLine();
    }
  }
}

Salida

Sheeran

El código anterior está en Asamblea1

En el ejemplo anterior, hemos creado una clase StudentName con un private protected campo nombre .

Observe que hemos heredado el Program1 clase del StudentName clase.

Desde el private protected se puede acceder al miembro desde clases derivadas dentro del mismo ensamblado, podemos acceder a name del Programa1 clase.

Derivamos una clase de StudentName en otro ensamblado e intente acceder al campo privado protegido nombre de eso. Por ejemplo,

// Code in Assembly2
using System;
//access Assembly1
using Assembly1;

namespace Assembly2 {

  //derived class of StudentName
  class Program : StudentName {
    static void Main(string[] args) {
      Program student = new Program();
    
      // accessing name field from Assembly1
      Console.Write(student.name);
      Console.ReadLine();
     }
  }
}

El código anterior está en Assembly2

En el ejemplo anterior, cuando intentamos acceder al nombre campo de la clase derivada de StudentName , obtenemos un error.

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

Esto se debe a que el nombre el campo está en Asamblea1 y la clase derivada está en Assembly2 .

Nota :También podemos usar modificadores de acceso con tipos (clases, interfaz, etc). Sin embargo, solo podemos usar tipos con modificadores de acceso público e interno.

Método C# Ámbito variable de C#

Lenguaje C