Modificadores de acesso C#

Neste tutorial, aprenderemos sobre os modificadores de acesso público, privado, protegido e interno em C# com a ajuda de exemplos.

Em C#, os modificadores de acesso especificam a acessibilidade de tipos (classes, interfaces, etc.) e membros de tipo (campos, métodos, etc). Por exemplo,

class Student {

  public string name;
    
  private int num;

  }

Aqui,

nome - campo público que pode ser acessado de qualquer lugar
num - campo privado só pode ser acessado dentro do Aluno aula

Tipos de modificadores de acesso

Em C#, existem 4 tipos básicos de modificadores de acesso.

público
privado
protegido
interno

1. modificador de acesso público

Quando declaramos um tipo ou membro de tipo public , pode ser acessado de qualquer lugar. Por exemplo,

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();
    }
  }
}

Saída

Name: Sheeran
Hello from Student class

No exemplo acima, criamos uma classe chamada Student com um campo nome e um método print() .

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

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

Como o campo e o método são públicos, podemos acessá-los a partir do Program classe.

Observação :Usamos o objeto student1 do Aluno classe para acessar seus membros. Para saber mais, visite a classe e objetos C# .

2. modificador de acesso privado

Quando declaramos um membro de tipo com o private modificador de acesso, ele só pode ser acessado dentro do mesmo class ou struct . Por exemplo,

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();
    }
  }
}

No exemplo acima, criamos uma classe chamada Student com um campo nome e um método print() .

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

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

Como o campo e o método são privados, não podemos acessá-los no Program classe. Aqui, o código irá gerar o seguinte erro.

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 acesso protegido

Quando declaramos um membro de tipo como protected , ele só pode ser acessado da mesma classe e suas classes derivadas. Por exemplo,

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();
    }
  }
}

No exemplo acima, criamos uma classe chamada Student com um campo nome . Como o campo está protegido, não podemos acessá-lo a partir do Program classe.

Aqui, o código irá gerar o seguinte erro.

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

Agora, vamos tentar acessar o protected membro de uma classe 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();
    }
  }
}

Saída

Name: Sheeran

No exemplo acima, criamos uma classe Aluno com um campo protegido nome . Observe que herdamos o Program turma do Aluno classe.

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

Desde o protected membro pode ser acessado de classes derivadas, podemos acessar name do Programa classe.

4. modificador de acesso interno

Quando declaramos um tipo ou membro de tipo como internal , ele pode ser acessado apenas dentro do mesmo assembly.

Um assembly é uma coleção de tipos (classes, interfaces, etc) e recursos (dados). Eles são construídos para trabalhar juntos e formar uma unidade lógica de funcionalidade.

É por isso que quando executamos um assembly, todas as classes e interfaces dentro do assembly são executadas juntas. Para saber mais, visite o Assembly C#.

Exemplo:interno dentro do mesmo Assembly

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();
    }
  }
}

Saída

Name: Sheeran

No exemplo acima, criamos uma classe chamada Student com um campo nome . Como o campo é internal , podemos acessá-lo a partir do Program classe como eles estão na mesma montagem.

Se usarmos internal dentro de um único assembly, funciona exatamente como o public modificador de acesso.

Exemplo:interno em montagem diferente

Vamos criar um assembly primeiro.

// Code on Assembly1
using System;

namespace Assembly1 {

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

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

Aqui, este código está em Assembly1 . Criamos um campo interno name dentro da classe Nome do Aluno . Agora, este campo só pode ser acessado a partir do mesmo assembly Assembly1 .

Agora, vamos criar outra montagem.

// 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();
     }
  }
}

Aqui, este código está em Assembly2 . Estamos tentando acessar o nome campo do Nome do Aluno class(Montagem1 ).

Para acessar campos de Assembly1 , primeiro precisamos definir a referência de Assembly1 em Montagem2 . Agora o código

using Assembly1;

nos permite usar o código de Assembly1 para Montagem2 .

Aqui, quando tentamos acessar o nome campo de Assembly2 , obtemos um erro.

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

Isso ocorre porque nome é um campo interno presente em Assembly1 .

5. modificador de acesso interno protegido

O protected internal é uma combinação de protected e internal modificadores de acesso.

Quando declaramos um membro protected internal , ele pode ser acessado do mesmo assembly e a classe derivada da classe que o contém de qualquer outro assembly.

// 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();
     }
  }
}

Saída

Hello

O código acima está em Assembly1 .

No exemplo acima, criamos uma classe chamada Greet com um campo msg . Como o campo é protegido internamente, podemos acessá-lo a partir do Program classe como eles estão na mesma montagem.

Vamos derivar uma classe de Greet em outro assembly e tente acessar o campo interno protegido msg a partir dele.

// 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();
    }
  }
}

Saída

Hello

O código acima está em Assembly2 .

No exemplo acima, herdamos o Program classe do Saudar class(de Assembly1 ).

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

Conseguimos acessar a msg da Saudações classe de Montagem1 de Assembly2 .

Isso ocorre porque a msg é um campo interno protegido e estamos tentando acessá-lo da classe filha de Greet .

6. modificador de acesso protegido privado

O private protected modificador de acesso é uma combinação de private e protected . Ele está disponível a partir do C# versão 7.2 e posterior.

Quando declaramos um membro private protected , ele só pode ser acessado dentro da mesma classe e sua classe derivada dentro do mesmo assembly. Por exemplo,

// 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();
    }
  }
}

Saída

Sheeran

O código acima está em Assembly1

No exemplo acima, criamos uma classe StudentName com um private protected campo nome .

Observe que herdamos o Program1 classe do Nome do Aluno classe.

Desde o private protected membro pode ser acessado de classes derivadas dentro do mesmo assembly, podemos acessar name do Program1 classe.

Vamos derivar uma classe de StudentName em outro assembly e tente acessar o campo protegido privado name a partir dele. Por exemplo,

// 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();
     }
  }
}

O código acima está em Assembly2

No exemplo acima, quando tentamos acessar o nome campo da classe derivada de StudentName , obtemos um erro.

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

Isso ocorre porque o nome campo está em Assembly1 e a classe derivada está em Assembly2 .

Observação :Também podemos usar modificadores de acesso com tipos (classes, interface, etc). No entanto, só podemos usar tipos com modificadores de acesso público e interno.

Método C# Escopo da variável C#

Linguagem C