C# Modificatore di accesso
Esempio # 01:
Prima di esaminare l'uso del modificatore di accesso interno, dobbiamo guardare prima il modificatore di accesso "privato" nella programmazione C#. Abbiamo avviato la nostra prima illustrazione con l'uso della libreria "Sistema". Quindi, abbiamo utilizzato lo spazio dei nomi definito dall'utente chiamato "nuovo" contenente un totale di due classi in esso.
La classe "test" contiene la funzione principale () in essa per avviare l'esecuzione di questo codice. La console.L'istruzione WriteLine () in questa funzione driver principale () viene utilizzata per visualizzare il testo "Metodo principale della classe di test" sui nostri schermi. Un oggetto "OBJ" per la classe "nuovo" è stato creato usando il nome della classe. La classe "New", contiene un membro dei dati privato "X" di tipo intero con il valore "14". Ciò significa che il valore della variabile "x" non può essere accessibile da qualsiasi altra funzione di altre classi anche se sono derivate.
La funzione principale () è l'utilizzo dell'oggetto "obj" della nuova classe per aggiornare il valore del membro dei dati privati "x" della classe "nuovo" i.e. Non è possibile in questo momento. Dopo aver chiamato la funzione show () con l'oggetto "obj" nel metodo principale (), l'esecuzione del metodo show () con il modificatore di accesso "pubblico" deve essere avviata. Non sembra che a causa del modificatore di accesso privato con la variabile "x". Entrambe le classi sono completate e il codice è pronto per l'uso. Dobbiamo salvarlo per primo con Ctrl+S ed uscire dall'editor chiudendolo usando il segno incrociato dall'editor di testo.
Dopo che il codice è stato salvato, è necessario compilarlo attraverso l'uso del compilatore "MCS" C# già configurato in Linux. Questo passaggio ci mostra l'errore che si è verificato alla riga 12 del nostro codice C#, i.e. Non è possibile accedere alla variabile "x" all'interno della classe di test in quanto è stata definita con il modificatore di accesso privato. Quindi, dobbiamo correggere questo errore.
Abbiamo nuovamente aperto il file C# nell'editor di testo e aggiornato il codice sostituendo il modificatore di accesso privato della variabile "X" con il modificatore di accesso pubblico. Non cambieremo il codice rimanente in quanto non è richiesto. Quindi, salva ancora una volta il codice appena aggiornato.
Quando abbiamo usato il comando del compilatore MCS sulla shell seguita dal nome di un file C#, il codice è stato compilato correttamente. Successivamente, abbiamo eseguito il file "EXE" creato dal compilatore di C# sulla shell e l'output è stato visualizzato i.e. Un valore di "x" è stato aggiornato.
Esempio # 02:
Ora, daremo un'occhiata all'uso dei modificatori di accesso interno per definire l'ambito di alcune variabili nelle classi del codice C#. Quindi, abbiamo iniziato questo esempio C# con l'uso della libreria di sistema e abbiamo creato uno spazio dei nomi "nuovo" in esso. Questo spazio dei nomi contiene due classi indipendenti denominate "Nuove" e "Test" in esso. La classe "test" contiene la funzione del codice driver principale (), mentre la "nuova" classe contiene la variabile intera "x" con un valore di 14 definito con il modificatore di accesso interno e la funzione show ().
Il nuovo oggetto di classe "OBJ" è stato generato con l'uso della parola chiave "nuova" seguita dal nome di una classe. Questo oggetto della nuova classe è stato utilizzato alla riga successiva per aggiornare il valore della variabile "X" per "0". Ora, la variabile "X" verrà aggiornata correttamente poiché la variabile "X" è definita con il modificatore di accesso interno all'interno dello stesso gruppo dello spazio dei nomi "Nuovo". La funzione Show () è stata chiamata con questo stesso oggetto "OBJ". Quando viene eseguita la funzione show (), visualizzerà il valore aggiornato di "x" sulla shell tramite la console.Dichiarazione della funzione WriteLine ().
È ora di salvare rapidamente il nostro file di codice con Ctrl+S e tornare di nuovo al terminale. Nella shell, abbiamo eseguito il comando "MCS" per la compilazione del codice C# per eseguire il "interno.File CS ". Questa compilazione ha avuto successo e il file "exe" compilato per l'interno.CS è stato creato nella nostra attuale directory di lavoro. Stiamo usando quel file "exe" per eseguirlo con il comando di runtime "mono" nella shell. L'output è stato visualizzato con successo come di seguito. La funzione principale () è stata eseguita prima come per la stringa visualizzata e successivamente, il valore aggiornato "0" di variabile "x" viene visualizzato correttamente.
Ecco come funziona un modificatore di accesso interno nel codice C# quando è stato utilizzato nello stesso spazio dei nomi. Apportiamo modifiche al nostro codice per vedere come un modificatore di accesso interno influisce sull'esecuzione del codice C# se utilizzato tra più di un gruppo. Supponiamo che tu abbia creato due spazi dei nomi nel tuo stesso codice C# I.e. Nuovo e test.
All'interno del nuovo spazio dei nomi, abbiamo creato una classe nuova e inizializzata una variabile "X" di modificatore di accesso interno con il valore 14. La stessa classe di Namspace new contiene la funzione show () per visualizzare il valore di "x". D'altra parte, il test dello spazio dei nomi contiene un test di classe con una funzione principale (). Questa funzione principale () sta creando un oggetto di classe nuovo dallo spazio dei nomi "nuovo". Lo stesso oggetto è stato utilizzato per modificare il valore della variabile "x" e chiamare la funzione show () per visualizzare il valore aggiornato della variabile "x". Ora, la variabile "X" è definita nello spazio dei nomi "nuovo", mentre l'oggetto sta cercando di accedervi all'interno dello spazio dei nomi "Test". A causa del modificatore di accesso interno con variabile "x", potremmo riscontrare un errore. Vediamolo adesso.
Dopo aver compilato questo codice, abbiamo ricevuto l'errore come previsto, io.e. tipo protetto.
Per evitare questo errore sulla compilazione, dobbiamo fare alcuni aggiornamenti al codice come abbiamo fatto nel codice sopra dall'ultimo codice. Quindi, abbiamo rimosso lo spazio dei nomi "nuovo" dal codice e non abbiamo rimosso lo spazio dei nomi dei test dal codice come mostrato sotto.
Dopo la compilazione e l'esecuzione del codice, è stato eseguito correttamente e ha visualizzato il valore modificato della variabile "x" sulla shell indipendentemente dal suo tipo interno.
Conclusione
Abbiamo finito di implementare gli esempi per il modificatore di accesso interno in C#. Abbiamo iniziato questo articolo con l'esempio della discussione del modificatore di accesso privato per confrontarlo con i modificatori di accesso interno in quanto entrambi fanno lo stesso lavoro a diversi livelli di programmazione. Abbiamo provato a utilizzare il modificatore di accesso interno all'interno dello stesso spazio dei nomi, due diversi spazi dei nomi e all'interno della classe non ha definito spazio dei nomi. In questo modo, abbiamo elaborato il suo utilizzo per la protezione delle variabili dei membri dei dati e la funzione in C#.