In diesem Artikel werden wir sehen, wie protected in c# im Detail implementiert werden kann. Mit Hilfe von Zugriffsmodifikatoren können wir die Zugänglichkeit von Parametern und Klassen einschränken. Es gibt folgende Zugriffsmodifikatoren in C#
In c# können wir den geschützten Modifikator verwenden, um anzugeben, dass der Zugriff auf den enthaltenden Typ beschränkt ist. Wir können es auch für die Typen verwenden, die von der enthaltenden Klasse abgeleitet sind. Das Wort „geschützt“ bedeutet, dass es für sich selbst und auch für die abgeleiteten Klassen zugänglich oder sichtbar sein kann.
Mit Hilfe dieses Mitglieds oder Typs kann nur auf Code zugegriffen werden, der in derselben Klasse oder in der abgeleiteten Klasse verwendet wird. Das Schlüsselwort protected liegt zwischen den privaten und öffentlichen Modifikatoren. Es ist fast dasselbe wie ein privater Modifikator, ermöglicht dem Mitglied jedoch den Zugriff auf die abgeleiteten Klassen. Wir verwenden das Schlüsselwort protected meistens, wenn wir ihren Eltern Zugriff auf die Eigenschaften von Kindern gewähren möchten. So können wir die Logik mithilfe des geschützten Schlüsselworts wiederverwenden.
Beispiel:
using System; class Test { protected int _x; private int _y; } class Test1 : Test { public Test1 () { // In this we can access the variable protected int but we cannot access private int variable Console.WriteLine(this._x); } } class Program { static void Main() { Test1 b = new Test1 (); } }
Berücksichtigen Sie zwei Klassen: Test und Test1. Die Klasse Test1 wird von Test abgeleitet. Wenn wir in die Klasse Test schauen, können wir sehen, dass zwei int-Felder deklariert wurden. 1 geschützt und 1 privat.
In Klasse B Test1 können wir auf das geschützte int zugreifen, aber nicht auf das private int. Der geschützte Modifikator gibt uns also zusätzlichen Zugriff auf die abgeleitete Klasse. Mit Hilfe des Schlüsselworts protected können wir also auf die geschützten Felder zugreifen, einschließlich aller abgeleiteten Klassen.
Eine Klasse kann auch geschützt werden. Unten finden Sie ein Beispiel für die Deklaration
Syntax:
public class Test { protected class Child { } }
Nur in einer verschachtelten Klasse können wir die Klasse als geschützt deklarieren. Wir können es nicht innerhalb eines Namespace definieren.
Im Folgenden finden Sie Beispiele, die zeigen, wie wir protected in C# implementieren können:
Code:
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ProtectedExample { class demo { // String Variable declared as protected protected string name; public void print() { Console.WriteLine("\name is " + name); } } class Program { static void Main(string[] args) // main method { demo d = new demo(); Console.Write("Enter your name:\t"); d.name = Console.ReadLine(); d.print(); Console.ReadLine(); } } }
Im obigen Beispiel wird die Zeichenfolge als geschützt deklariert. Dieses Programm löst einen Fehler aus, da protected seine Mitglieder vor anderen Klassen verbirgt. Es ist also nur im Kinderunterricht zugänglich.
Code:
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ProtectedExample { class Demo { protected string name = "Protected Keyword"; protected void Display(string val) { Console.WriteLine("This is " + val); } } class Program : Demo // inheritance { static void Main(string[] args) { Program program = new Program(); // Accessing protected variable Console.WriteLine("This is " + program.name); // Accessing protected function program.Display("protected example"); Console.ReadLine(); } } }
Im obigen Beispiel besteht die übergeordnete Klasse aus geschützten Mitgliedern. Protected wird zum Deklarieren der Zeichenfolge verwendet. Jetzt wird die untergeordnete Klasse von einer übergeordneten Klasse abgeleitet und das Konzept der Vererbung wird verwendet, um auf die geschützten Mitglieder zuzugreifen.
Ausgabe:
Code:
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ProtectedExample { class Parent { private String Private = "My name is John"; // string declared as private protected String Protected = "My name is Dan"; // string declared as protected } class Child : Parent // inheritance { public void Show() { Console.WriteLine(Protected); } } class Program { static int Main(string[] args) // main method { Child child = new Child(); // child object child.Show(); Console.ReadKey(); return 0; } } }
Im obigen Beispiel enthält die übergeordnete Klasse private und geschützte Zeichenfolgen. Die untergeordnete Klasse wird von der übergeordneten Klasse abgeleitet. Show() kann zwar nicht auf „Private“ zugreifen, wohl aber auf „Protected“. Zum Aufrufen der Methode wird ein untergeordnetes Klassenobjekt verwendet. Protected wird verwendet, um die Mitglieder vor dem Zugriff außerhalb des Unterrichts zu schützen.
Ausgabe:
Wir können den Konstruktor auch als geschützt deklarieren. Indem wir also einen beliebigen Konstruktor als geschützt deklarieren, können wir ihn von einer Unterklasse aus aufrufen.
Syntax:
public class TEst : Test1 { public Test() : base() // here we can Call the protected base constructor { } }
Wir können keine geschützte Methode aufrufen. Wir können den geschützten Konstruktor aus der abgeleiteten Klasse aufrufen.
Mit Hilfe von protected internal können wir festlegen, dass der Zugriff auf aktuelle Typen beschränkt ist, die von den enthaltenden Klassen abgeleitet sind. Dadurch wird sichergestellt, dass auf das Mitglied und den Typ über Code in derselben Klasse oder über die abgeleitete Klasse, die in einer anderen Assembly geschrieben ist, zugegriffen werden kann.
Beispiel:
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ProtectedExample { class Demo { protected internal string name; // variable is declared as protected internal public void print() { Console.WriteLine("name is " + name); } } class Program { static void Main(string[] args) // main method { Demo d = new Demo(); Console.Write("Enter your name:\t"); // Accepting value in protected internal variable d.name = Console.ReadLine(); d.print(); Console.ReadLine(); } } }
Ausgabe:
Das geschützte Schlüsselwort ist nützlich, da auf diese Art von Variable durch den Code zugegriffen werden kann, der in derselben Klasse verwendet wird. Dies ist nützlich, wenn wir einer untergeordneten Klasse Berechtigungen erteilen möchten, damit diese auf Mitglieder der übergeordneten Klasse zugreifen kann. In diesem Sinne ist es wichtig, die Wiederverwendbarkeit des Codes zu erreichen.
Wir können also protected with-Variablen verwenden und über das Vererbungskonzept auf sie zugreifen. Es kann verwendet werden, wenn die Klasse selbst oder eine Unterklasse auf Mitglieder zugreifen kann.
Das obige ist der detaillierte Inhalt vonGeschützt in C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!