Introdução aos modificadores de acesso em c #

Este artigo aborda o conceito mais elementar de programação orientada a objetos da perspectiva da linguagem de programação C #. O conceito é conhecido como - Modificadores de Acesso. A primeira pergunta a ser respondida é: o que são modificadores de acesso? Simplificando, os modificadores de acesso controlam quais objetos / variáveis ​​/ constantes / métodos (praticamente tudo) podem ser acessados ​​em qual parte do código. Modificadores de acesso desempenham um papel importante na verificação do conceito de Abstração na programação orientada a objetos. Eles controlam qual parte do programa deve ser e não deve ser visível para o usuário final. Obviamente, um usuário final está menos preocupado com as constantes e variáveis ​​envolvidas no algoritmo. Ele está preocupado apenas com o método que ele precisa chamar para obter a saída.

Tipos de modificadores de acesso em c #

O C # nos fornece quatro tipos de modificadores de acesso:

  • Privado (o modificador de acesso padrão, exceto enumerações e interfaces)
  • Protegido (ligeiramente restrito)
  • Público (irrestrito, a opção padrão para enumerações e interfaces)
  • Interno (público dentro da mesma montagem)

Além desses quatro modificadores de acesso, há mais duas combinações de níveis de acesso:

  • Interno protegido
  • Privado Protegido

Vamos entender cada um com um exemplo.

1. Privado

Privado é o nível de acesso mais restrito. Também é o modificador de acesso padrão para todas as constantes, variáveis, objetos definidos pelo usuário, etc. Somente enumerações e interfaces são públicas por padrão. Portanto, se você não especificar nenhum modificador de acesso, o C # atribui o modificador padrão a ele.

Objetos particulares não são acessíveis fora do corpo da classe ou estrutura ou seção do programa em que são declarados. Qualquer tentativa de acessar o objeto fora do escopo do corpo no qual é declarado resulta em um erro em tempo de compilação.

Exemplo 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);
)
)

Saída 1:

Exemplo 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);
)
)

Saída 2:

2. Protegido

O especificador de acesso protegido restringe um objeto a ser acessível apenas a partir de instâncias derivadas da classe. Portanto, se um objeto de classe filho tentar acessar os objetos protegidos de uma classe pai, será permitido. Classes não derivadas não podem acessar membros protegidos de nenhuma classe. Obviamente, objetos protegidos são acessíveis a métodos da própria classe.

Exemplo

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

Saída 3:

3. Público

Este é o modificador de acesso menos restrito. Objetos públicos são praticamente acessíveis a todo o mundo exterior, tornando-o o mais alto modificador de acesso permitido. Obviamente, isso tem um alto custo - o custo da menor proteção.

Os membros públicos podem ser acessados ​​por qualquer parte do código. Isso os torna menos seguros. Qualquer lógica de código pode modificar seu valor, o que pode levar a um comportamento inesperado. Portanto, é preciso ter muito cuidado antes de tornar público qualquer objeto.

Na mesma classe Employee que criamos em nosso exemplo de modificador de acesso privado, se alterarmos o nível de acesso ao público, não precisaremos de nenhum método Getter e Setter. De fato, a melhor prática é tornar o objeto privado e usar as propriedades C # Getter e Setter.

Exemplo

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

Saída 4:

4. Interno

Objetos e métodos internos são acessíveis apenas dentro do mesmo conjunto. Este é um modificador de acesso muito útil quando você deseja tornar qualquer objeto público e, no entanto, deseja restringir seu acesso apenas à estrutura que você está codificando.

Portanto, em essência, todos os objetos internos são acessíveis por todas as áreas da mesma montagem.

Vamos criar dois aplicativos de console para entender esse trabalho.

Exemplo

Etapa 1: Crie um aplicativo de console C # e coloque o código abaixo nele:

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

Etapa 2: crie a solução para obter o arquivo .dll da pasta bin.

Etapa 3: Crie outro aplicativo de console e faça referência ao arquivo de montagem do ConsoleApp1. Clique em Adicionar referência na imagem abaixo e navegue até o local do arquivo .dll na etapa 2. Ele deve ser semelhante a ~ / ConsoleApp1 / bin / Debug / ConsoleApp1.dll.

Depois de adicionar o arquivo .dll, você deve encontrá-lo em Assemblies.

Etapa 4: Coloque o código abaixo no 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);
)
)
)

Etapa 5: Ao criar o ConsoleApp2, você obteria um erro em tempo de compilação indicando que 'x' do ConsoleApp1 não pode ser acessado em outros assemblies devido ao seu nível de proteção.

5. Interno protegido

Essa é uma combinação dos modificadores de acesso interno e protegido. Um conceito importante a ser entendido aqui é que Interno Protegido significa Interno Protegido. É uma união dos dois modificadores de acesso. Nunca deve ser pensado para ser um cruzamento.

Portanto, objetos internos não estão acessíveis fora da montagem, enquanto objetos protegidos estão acessíveis a qualquer classe derivada em qualquer montagem. E se eu quiser proteger meu objeto apenas em outras montagens e não na mesma montagem? Solução simples - declare-a como interna protegida.

Exemplo

Etapa 1: vamos modificar nosso ConsoleApp1 para refletir o código abaixo. Observe que alteramos o nível de acesso de nossa variável 'x' para 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);
)
)
)

Etapa 2: crie a solução novamente e substitua a .dll no ConsoleApp2 pela atualizada.

Etapa 3: atualize o código no ConsoleApp2 como abaixo:

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

Etapa 4: Execute o ConsoleApp2 para ver a saída.

6. Protegido Privado

Essa é uma combinação de união dos modificadores de acesso Privado e Protegido. Interno protegido significa Protegido OU Interno. Portanto, objetos privados não podem ser acessados ​​fora do bloco de código no qual é declarado, enquanto objetos protegidos são acessíveis a qualquer classe derivada em qualquer assembly. E se eu quiser restringir o acesso do meu objeto, mesmo em classes derivadas em outros assemblies? Solução simples - declare-a como interna protegida.

Exemplo

Vamos modificar o nível de acesso de 'x' no ConsoleApp1 para 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();
)
)
)

Resultado:

Comparação tabular

Especificador de acesso Mesma montagem Outra Assembléia
Mesma classeClasse derivadaClasse não derivadaClasse derivadaClasse não derivada
PrivadosimNãoNãoNãoNão
Públicosimsimsimsimsim
ProtegidosimsimNãosimNão
internosimsimsimNãoNão
Interno protegidosimsimsimsimNão
Privado ProtegidosimsimNãoNãoNão

Conclusão

Vimos no artigo acima que modificadores de acesso controlam o acesso de tudo no projeto. Várias combinações de níveis de acesso cobrem as necessidades de vários tipos de acessibilidade. Os desenvolvedores devem escolher sabiamente, tendo em mente a segurança e a necessidade absoluta do objeto de estar acessível em um determinado bloco de código.

Artigos recomendados

Este é um guia para os Modificadores de Acesso em C #. Aqui discutimos os tipos de introdução de modificadores de acesso em C #, juntamente com exemplos e saídas. Você também pode consultar nossos outros artigos sugeridos para saber mais:

  1. Compiladores C #
  2. Destruidor em c #
  3. O que é o TypeScript?
  4. O que é o ASP.Net Web Services?
  5. Modificadores de acesso em PHP
  6. Trabalho e os 3 principais métodos enum em C #