C# interno
Esempio 01
Prima di utilizzare il modificatore di accesso interno, dobbiamo prima esaminare il modificatore di accesso "privato" nella programmazione C#. Quindi, abbiamo utilizzato lo spazio dei nomi definito dall'utente chiamato "nuovo", contenente due classi. La classe "test" contiene la funzione principale () 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 "new", 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 aver luogo. 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 aver salvato il codice, è necessario compilarlo utilizzando il compilatore "MCS" C# già configurato in Linux. Questo passo indispensabile ci mostra che l'errore si è verificato alla riga 12 del nostro codice C#, i.e., Non è possibile accedere alla variabile "x" all'interno della classe di test come definito 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, abbiamo risparmiato di nuovo 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'uscita è stata visualizzata, i.e., Un valore di "x" è stato aggiornato.
Esempio 02
Ora, daremo un'occhiata all'uso di modificatori di accesso interno per definire l'ambito di alcune variabili nelle classi del codice C#. Quindi, abbiamo avviato questo esempio C# con l'aggiunta della libreria di sistema e creato uno spazio dei nomi "nuovo" in esso. Questo spazio dei nomi contiene due classi indipendenti denominate "New" e "Test."La classe" test "contiene la funzione del codice driver principale (), mentre la classe" nuova "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 utilizzando la "nuova" parola chiave seguita dal nome di una classe. Questo nuovo oggetto di 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 un 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. Abbiamo eseguito il comando "MCS" per la compilazione del codice C# per eseguire "Internal.file cs "nella shell. Questa compilation ha avuto successo e il file "exe" compilato per l'interno.CS è stato creato nella nostra attuale directory di lavoro. Usiamo 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 () viene eseguita prima come per la stringa visualizzata e, successivamente, viene visualizzato correttamente il valore aggiornato "0" di variabile "x".
Ecco come funziona un modificatore di accesso interno nel codice C# se 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. Hai creato due nomi spazi nel tuo stesso codice C#, io.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 nomi dello spazio nuovo 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 dall'altro 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 degli altri 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 aggiornare il 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 dopo questo aggiornamento, è 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 spazi nomi diversi e nessun spazio dei nomi definito all'interno della classe. Abbiamo elaborato il suo utilizzo per proteggere le variabili dei membri dei dati e la funzione in C#.