Introduzione ai modificatori di accesso in C #
Questo articolo tratta il concetto più elementare di programmazione orientata agli oggetti dal punto di vista del linguaggio di programmazione C #. Il concetto è noto come - Modificatori di accesso. La prima domanda a cui rispondere è: che cosa sono i modificatori di accesso? In poche parole, i modificatori di accesso controllano a quali oggetti / variabili / costanti / metodi (praticamente tutto) è possibile accedere in quale parte del codice. I modificatori di accesso svolgono un ruolo importante nella correzione del concetto di astrazione nella programmazione orientata agli oggetti. Controllano quale parte del programma dovrebbe essere e non dovrebbe essere visibile all'utente finale. Naturalmente, l'utente finale è meno preoccupato per le costanti e le variabili coinvolte nell'algoritmo. Si preoccupa solo del metodo che deve invocare per ottenere l'output.
Tipi di modificatori di accesso in C #
C # ci offre quattro tipi di modificatori di accesso:
- Privato (il modificatore di accesso predefinito, tranne enumerazioni e interfacce)
- Protetto (leggermente limitato)
- Pubblico (senza restrizioni, la scelta predefinita per enumerazioni e interfacce)
- Interno (pubblico all'interno della stessa assemblea)
Oltre a questi quattro modificatori di accesso, ci sono altre due combinazioni di livelli di accesso:
- Interno protetto
- Protetto privato
Cerchiamo di capire ciascuno con un esempio.
1. Privato
Privato è il livello di accesso più limitato. È anche il modificatore di accesso predefinito per tutte le costanti, variabili, oggetti definiti dall'utente, ecc. Solo gli enumeratori e le interfacce sono pubblici per impostazione predefinita. Pertanto, se non si specifica alcun modificatore di accesso, C # gli assegna il modificatore predefinito.
Gli oggetti privati non sono accessibili al di fuori del corpo della classe o della struttura o sezione del programma in cui sono dichiarati. Qualsiasi tentativo di accedere all'oggetto al di fuori dell'ambito del corpo in cui viene dichiarato genera un errore in fase di compilazione.
Esempio 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);
)
)
Uscita 1:
Esempio n. 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);
)
)
Uscita 2:
2. Protetto
L'identificatore di accesso protetto limita l'accesso a un oggetto solo dalle istanze derivate della classe. Pertanto, se un oggetto di classe figlio tenta di accedere agli oggetti protetti di una classe genitore, è consentito. Le classi non derivate non possono accedere ai membri protetti di nessuna classe. Naturalmente, gli oggetti protetti sono accessibili ai metodi della propria classe.
Esempio
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);
)
)
Uscita 3:
3. Pubblico
Questo è il modificatore di accesso meno limitato. Gli oggetti pubblici sono praticamente accessibili a tutto il mondo esterno, rendendolo quindi il modificatore di accesso più alto consentito. Naturalmente, questo ha un costo elevato: il costo della minima protezione.
I membri pubblici sono accessibili da qualsiasi parte del codice. Questo li rende meno sicuri. Qualsiasi logica di codice può modificare il loro valore che può portare a comportamenti imprevisti. Quindi, bisogna essere molto cauti prima di rendere pubblico qualsiasi oggetto.
Nella stessa classe Employee che abbiamo creato nel nostro esempio di modificatore di accesso privato, se cambiamo il livello di accesso al pubblico non avremmo bisogno di alcun metodo Getter e Setter. In effetti, la pratica migliore è rendere l'oggetto privato e usare le proprietà Getter e Setter di C #.
Esempio
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);
)
)
Uscita 4:
4. Interno
Oggetti e metodi interni sono accessibili solo all'interno dello stesso assieme. Questo è un modificatore di accesso molto utile quando si desidera rendere pubblico qualsiasi oggetto e tuttavia si desidera limitarne l'accesso solo al framework che si sta codificando.
Quindi, in sostanza, tutti gli oggetti interni sono accessibili da tutte le aree dello stesso assieme.
Creiamo due applicazioni console per capire questo funzionamento.
Esempio
Passaggio 1: creare un'applicazione console C # e inserire il codice seguente:
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);
)
)
)
Passaggio 2: compilare la soluzione per ottenere il file DLL dalla cartella bin.
Passaggio 3: creare un'altra applicazione console e fare riferimento al file assembly da ConsoleApp1. Fare clic su Aggiungi riferimento nell'immagine seguente e selezionare il percorso del file .dll dal passaggio 2. Deve essere simile a ~ / ConsoleApp1 / bin / Debug / ConsoleApp1.dll.
Dopo aver aggiunto il file DLL, lo si dovrebbe trovare in Assiemi.
Passaggio 4: inserire il codice seguente in 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);
)
)
)
Passaggio 5: Quando si crea ConsoleApp2, si otterrebbe un errore di compilazione che indica che non è possibile accedere a 'x' da ConsoleApp1 in altri assembly a causa del suo livello di protezione.
5. Interno protetto
Questa è una combinazione di modificatori di accesso protetto e interno. Un concetto importante da capire qui è che Protected Internal significa Protected OR Internal. È un'unione di entrambi i modificatori di accesso. Non si deve mai pensare che sia un incrocio.
Pertanto, gli oggetti interni non sono accessibili all'esterno dell'assieme, mentre gli oggetti protetti sono accessibili a qualsiasi classe derivata in qualsiasi assieme. Cosa succede se desidero proteggere il mio oggetto solo in altri assembly e non nello stesso assembly? Soluzione semplice: dichiaralo come interno protetto.
Esempio
Passaggio 1: modificiamo la nostra ConsoleApp1 per riflettere il codice seguente. Si noti che abbiamo modificato il livello di accesso della nostra variabile 'x' in interno protetto.
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);
)
)
)
Passaggio 2: compilare nuovamente la soluzione e sostituire il file DLL in ConsoleApp2 con quello aggiornato.
Passaggio 3: aggiorna il codice in ConsoleApp2 come di seguito:
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();
)
)
)
Passaggio 4: eseguire ConsoleApp2 per visualizzare l'output.
6. Protetto privato
Questa è una combinazione di unione di modificatori di accesso sia privati che protetti. Interno protetto significa Protetto O Interno. Pertanto, gli oggetti privati non sono accessibili al di fuori del blocco di codice in cui viene dichiarato, mentre gli oggetti protetti sono accessibili a qualsiasi classe derivata in qualsiasi assembly. Cosa succede se desidero limitare l'accesso al mio oggetto anche nelle classi derivate in altri assembly? Soluzione semplice: dichiaralo come interno protetto.
Esempio
Modifichiamo il livello di accesso di 'x' in ConsoleApp1 su 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();
)
)
)
Produzione:
Confronto tabulare
| Identificatore di accesso | Stesso assemblaggio | Altra Assemblea | |||
| Stessa classe | Classe derivata | Classe non derivata | Classe derivata | Classe non derivata | |
| Privato | sì | No | No | No | No |
| Pubblico | sì | sì | sì | sì | sì |
| protetta | sì | sì | No | sì | No |
| Interno | sì | sì | sì | No | No |
| Interno protetto | sì | sì | sì | sì | No |
| Protetto privato | sì | sì | No | No | No |
Conclusione
Abbiamo visto nell'articolo sopra che i modificatori di accesso controllano l'accesso a tutto il progetto. Varie combinazioni di livelli di accesso coprono le esigenze di vari tipi di accessibilità. Gli sviluppatori devono scegliere saggiamente tenendo presente la sicurezza e l'assoluta necessità dell'oggetto di essere accessibili in un determinato blocco di codice.
Articoli consigliati
Questa è una guida ai modificatori di accesso in C #. Qui abbiamo discusso i tipi di introduzione di modificatori di accesso in C # insieme ad esempi e output. Puoi anche consultare i nostri altri articoli suggeriti per saperne di più–
- Compilatori C #
- Distruttore in C #
- Che cos'è TypeScript?
- Cosa sono i servizi Web ASP.Net?
- Modificatori di accesso in PHP
- Lavorare e primi 3 metodi Enum in C #