Einführung in Zugriffsmodifikatoren in C #
Dieser Artikel behandelt das elementarste Konzept der objektorientierten Programmierung aus der Perspektive der Programmiersprache C #. Das Konzept ist bekannt als - Access Modifiers. Die allererste zu beantwortende Frage lautet: Was sind Zugriffsmodifikatoren? Einfach ausgedrückt steuern Zugriffsmodifikatoren, auf welche Objekte / Variablen / Konstanten / Methoden (praktisch auf alles) in welchem Teil des Codes zugegriffen werden kann. Zugriffsmodifikatoren spielen eine wichtige Rolle bei der Überprüfung des Konzepts der Abstraktion in der objektorientierten Programmierung. Sie steuern, welcher Teil des Programms für den Endbenutzer sichtbar sein soll und welcher nicht. Natürlich ist ein Endbenutzer am wenigsten besorgt über die Konstanten und Variablen, die an dem Algorithmus beteiligt sind. Er ist nur darüber besorgt, welche Methode er aufrufen muss, um die Ausgabe zu erhalten.
Arten von Zugriffsmodifikatoren in C #
C # bietet uns vier Arten von Zugriffsmodifikatoren:
- Privat (der Standardzugriffsmodifikator mit Ausnahme von Aufzählungen und Schnittstellen)
- Geschützt (leicht eingeschränkt)
- Öffentlich (uneingeschränkt, die Standardauswahl für Enums und Interfaces)
- Intern (öffentlich innerhalb derselben Versammlung)
Abgesehen von diesen vier Zugriffsmodifikatoren gibt es zwei weitere Kombinationen von Zugriffsebenen:
- Intern geschützt
- Privat geschützt
Lassen Sie uns jedes anhand eines Beispiels verstehen.
1. Privat
Privat ist die am meisten eingeschränkte Zugriffsebene. Es ist auch der Standardzugriffsmodifikator für alle Konstanten, Variablen, benutzerdefinierten Objekte usw. Standardmäßig sind nur Enums und Interfaces öffentlich. Wenn Sie also keinen Zugriffsmodifikator angeben, weist C # ihm den Standardmodifikator zu.
Auf private Objekte kann nicht außerhalb des Hauptteils der Klasse oder Struktur oder des Programmabschnitts zugegriffen werden, in dem sie deklariert sind. Jeder Versuch, auf das Objekt außerhalb des Gültigkeitsbereichs des Körpers zuzugreifen, in dem es deklariert ist, führt zu einem Fehler bei der Kompilierung.
Beispiel 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);
)
)
Ausgang 1:
Beispiel # 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);
)
)
Ausgang 2:
2. Geschützt
Der Protected-Access-Specifier beschränkt den Zugriff auf ein Objekt nur auf abgeleitete Instanzen der Klasse. Wenn also ein untergeordnetes Klassenobjekt versucht, auf die geschützten Objekte einer übergeordneten Klasse zuzugreifen, ist dies zulässig. Nicht abgeleitete Klassen können nicht auf geschützte Mitglieder einer Klasse zugreifen. Natürlich sind geschützte Objekte für Methoden der eigenen Klasse zugänglich.
Beispiel
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);
)
)
Ausgang 3:
3. Öffentlich
Dies ist der am wenigsten eingeschränkte Zugriffsmodifikator. Öffentliche Objekte sind für die gesamte Außenwelt praktisch zugänglich und damit der höchstzulässige Zugriffsmodifikator. Dies ist natürlich mit hohen Kosten verbunden - den Kosten des geringsten Schutzes.
Auf öffentliche Mitglieder kann mit jedem Teil des Codes zugegriffen werden. Dies macht sie am wenigsten sicher. Jede Codelogik kann ihren Wert ändern, was zu unerwartetem Verhalten führen kann. Man muss also sehr vorsichtig sein, bevor man ein Objekt veröffentlicht.
In derselben Employee-Klasse, die wir in unserem Beispiel für den Modifikator "Privater Zugriff" erstellt haben, benötigen wir keine Getter- und Setter-Methoden, wenn wir die Zugriffsebene in "Öffentlich" ändern. Tatsächlich empfiehlt es sich, das Objekt privat zu machen und C # Getter- und Setter-Eigenschaften zu verwenden.
Beispiel
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);
)
)
Ausgang 4:
4. Intern
Auf interne Objekte und Methoden kann nur innerhalb derselben Assembly zugegriffen werden. Dies ist ein sehr nützlicher Zugriffsmodifikator, wenn Sie ein Objekt öffentlich machen und dennoch den Zugriff nur auf das Framework beschränken möchten, das Sie codieren.
Im Wesentlichen sind alle internen Objekte für alle Bereiche derselben Baugruppe zugänglich.
Lassen Sie uns zwei Konsolenanwendungen erstellen, um dies zu verstehen.
Beispiel
Schritt 1: Erstellen Sie eine C # -Konsolenanwendung und fügen Sie den folgenden Code ein:
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);
)
)
)
Schritt 2: Erstellen Sie die Lösung, um die DLL-Datei aus dem Ordner bin abzurufen.
Schritt 3: Erstellen Sie eine weitere Konsolenanwendung und verweisen Sie auf die Assemblydatei von ConsoleApp1. Klicken Sie im folgenden Bild auf Verweis hinzufügen und suchen Sie den Speicherort der DLL-Datei aus Schritt 2. Sie muss ~ / ConsoleApp1 / bin / Debug / ConsoleApp1.dll entsprechen.
Nachdem Sie die DLL-Datei hinzugefügt haben, sollten Sie sie unter Assemblies finden.
Schritt 4: Fügen Sie den folgenden Code in ConsoleApp2 ein.
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);
)
)
)
Schritt 5: Wenn Sie ConsoleApp2 erstellen, wird beim Kompilieren ein Fehler angezeigt, der darauf hinweist, dass auf 'x' von ConsoleApp1 in anderen Assemblys aufgrund der Schutzstufe nicht zugegriffen werden kann.
5. Intern geschützt
Dies ist eine Kombination aus geschützten und internen Zugriffsmodifikatoren. Ein wichtiges Konzept, das hier verstanden werden muss, ist, dass Geschütztes Inneres Geschütztes ODER Inneres bedeutet. Es ist eine Vereinigung beider Zugriffsmodifikatoren. Man darf niemals denken, dass es sich um eine Kreuzung handelt.
Interne Objekte sind außerhalb der Assembly nicht verfügbar, während geschützte Objekte für alle abgeleiteten Klassen in jeder Assembly verfügbar sind. Was ist, wenn ich mein Objekt nur in anderen Baugruppen und nicht in derselben Baugruppe schützen möchte? Einfache Lösung - deklarieren Sie es als geschütztes internes.
Beispiel
Schritt 1: Lassen Sie uns unsere ConsoleApp1 so ändern, dass sie den folgenden Code enthält. Beachten Sie, dass wir die Zugriffsebene unserer Variablen 'x' in protected internal geändert haben.
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);
)
)
)
Schritt 2: Erstellen Sie die Lösung erneut und ersetzen Sie die DLL in ConsoleApp2 durch die aktualisierte.
Schritt 3: Aktualisieren Sie den Code in ConsoleApp2 wie folgt:
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();
)
)
)
Schritt 4: Führen Sie ConsoleApp2 aus, um die Ausgabe anzuzeigen.
6. Privat geschützt
Dies ist eine gewerkschaftliche Kombination von Modifikatoren für den privaten und den geschützten Zugriff. Geschütztes internes bedeutet geschütztes ODER internes. Auf private Objekte kann außerhalb des Codeblocks, in dem sie deklariert sind, nicht zugegriffen werden, während geschützte Objekte für abgeleitete Klassen in Assemblys verfügbar sind. Was ist, wenn ich den Zugriff meines Objekts auch in abgeleiteten Klassen in anderen Assemblys einschränken möchte? Einfache Lösung - deklarieren Sie es als geschütztes internes.
Beispiel
Ändern Sie die Zugriffsebene von "x" in ConsoleApp1 in "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();
)
)
)
Ausgabe:
Tabellarischer Vergleich
| Zugriffsspezifizierer | Gleiche Versammlung | Andere Versammlung | |||
| Selbe Klasse | Abgeleitete Klasse | Nicht abgeleitete Klasse | Abgeleitete Klasse | Nicht abgeleitete Klasse | |
| Privat | Ja | Nein | Nein | Nein | Nein |
| Öffentlichkeit | Ja | Ja | Ja | Ja | Ja |
| Geschützt | Ja | Ja | Nein | Ja | Nein |
| Intern | Ja | Ja | Ja | Nein | Nein |
| Intern geschützt | Ja | Ja | Ja | Ja | Nein |
| Privat geschützt | Ja | Ja | Nein | Nein | Nein |
Fazit
In dem obigen Artikel haben wir gesehen, dass Zugriffsmodifikatoren den Zugriff auf alles im Projekt steuern. Verschiedene Kombinationen von Zugriffsebenen decken die Anforderungen verschiedener Arten der Barrierefreiheit ab. Die Entwickler müssen die Sicherheit und die absolute Notwendigkeit des Zugriffs auf das Objekt in einem bestimmten Codeblock mit Bedacht auswählen.
Empfohlene Artikel
Dies ist eine Anleitung zu den Access Modifiers in C #. Hier haben wir die Einführungstypen von Zugriffsmodifikatoren in C # zusammen mit Beispielen und Ausgaben besprochen. Sie können auch unsere anderen Artikelvorschläge durchgehen, um mehr zu erfahren.
- C # -Compiler
- Destruktor in C #
- Was ist TypeScript?
- Was sind ASP.Net-Webdienste?
- Zugriffsmodifikatoren in PHP
- Arbeits- und Top-3-Aufzählungsmethoden in C #