Inleiding tot toegangsmodificaties in C #
Dit artikel behandelt het meest elementaire concept van objectgeoriënteerd programmeren vanuit het perspectief van C # programmeertaal. Het concept staat bekend als - Access Modifiers. De allereerste vraag die moet worden beantwoord is - Wat zijn Access Modifiers? Simpel gezegd, toegangsmodificeerders bepalen welke objecten / variabelen / constanten / methoden (praktisch alles) toegankelijk zijn in welk deel van de code. Toegangsmodificatoren spelen een belangrijke rol bij het bewijzen van het concept van abstractie in objectgeoriënteerd programmeren. Ze bepalen welk deel van het programma wel en niet zichtbaar moet zijn voor de eindgebruiker. Natuurlijk is een eindgebruiker het minst bezorgd over de constanten en variabelen die bij het algoritme zijn betrokken. Hij maakt zich alleen zorgen over welke methode hij moet gebruiken om de output te krijgen.
Soorten toegangsmodificaties in C #
C # biedt ons vier soorten toegangsmodificaties:
- Privé (de standaard toegangsmodificatie, behalve enums en interfaces)
- Beschermd (enigszins beperkt)
- Openbaar (onbeperkt, de standaardkeuze voor enums en interfaces)
- Intern (openbaar binnen dezelfde vergadering)
Afgezien van deze vier toegangsmodificaties, zijn er nog twee combinaties van toegangsniveaus–
- Beschermd intern
- Privé beschermd
Laten we elk begrijpen met een voorbeeld.
1. Privé
Privé is het meest beperkte toegangsniveau. Het is ook de standaard toegangsmodificator voor alle constanten, variabelen, door de gebruiker gedefinieerde objecten, enz. Alleen enums en interfaces zijn standaard openbaar. Dus als u geen toegangsmodificator opgeeft, wijst C # de standaardmodificator eraan toe.
Privéobjecten zijn niet toegankelijk buiten het hoofdgedeelte van de klasse of de structuur of het programmagedeelte waarin ze zijn aangegeven. Elke poging om toegang te krijgen tot het object buiten het bereik van het lichaam waarin het wordt aangegeven, resulteert in een compilatie-fout.
Voorbeeld 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);
)
)
Uitgang 1:
Voorbeeld 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);
)
)
Uitgang 2:
2. Beschermd
De beveiligde toegangsspecificatie beperkt een object zodat het alleen toegankelijk is vanuit afgeleide instanties van de klasse. Dus als een object van een onderliggende klasse toegang probeert te krijgen tot de beschermde objecten van een bovenliggende klasse, is dit toegestaan. Niet-afgeleide klassen hebben geen toegang tot beschermde leden van enige klasse. Natuurlijk zijn beschermde objecten toegankelijk voor methoden van eigen klasse.
Voorbeeld
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);
)
)
Uitgang 3:
3. Openbaar
Dit is de minst beperkte toegangsmodificator. Openbare objecten zijn praktisch toegankelijk voor de hele buitenwereld, waardoor het de hoogst toelaatbare toegangsmodificator is. Dit brengt natuurlijk hoge kosten met zich mee - de kosten van de minste bescherming.
Openbare leden zijn toegankelijk voor elk deel van de code. Dit maakt ze het minst veilig. Elke codelogica kan hun waarde wijzigen, wat kan leiden tot onverwacht gedrag. Je moet dus heel voorzichtig zijn voordat je een object openbaar maakt.
In dezelfde Werknemersklasse die we in ons voorbeeld van privétoegangsmodificator hebben gemaakt, hebben we geen Getter- en Setter-methoden nodig als we het toegangsniveau voor iedereen wijzigen. In feite is de beste praktijk om het object privé te maken en de eigenschappen C # Getter en Setter te gebruiken.
Voorbeeld
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);
)
)
Uitgang 4:
4. Intern
Interne objecten en methoden zijn alleen toegankelijk binnen dezelfde assembly. Dit is een zeer nuttige toegangsmodificator wanneer u een object openbaar wilt maken en toch de toegang wilt beperken tot het framework dat u codeert.
Dus in wezen zijn alle interne objecten toegankelijk voor alle gebieden van dezelfde assemblage.
Laten we twee consoletoepassingen maken om dit te begrijpen.
Voorbeeld
Stap 1: Maak een C # Console-toepassing en plaats de onderstaande code erin:
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);
)
)
)
Stap 2: Bouw de oplossing om het DLL-bestand uit de map bin te halen.
Stap 3: Maak een andere consoleapplicatie en verwijs naar het assemblagebestand vanuit ConsoleApp1. Klik in de onderstaande afbeelding op Referentie toevoegen en blader naar de locatie van het DLL-bestand uit stap 2. Het moet lijken op ~ / ConsoleApp1 / bin / Debug / ConsoleApp1.dll.
Nadat u het .dll-bestand hebt toegevoegd, zou u het moeten vinden onder Assemblies.
Stap 4: Plaats de onderstaande code 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);
)
)
)
Stap 5: Wanneer u ConsoleApp2 bouwt, krijgt u een compilatietijdfout die aangeeft dat 'x' vanuit ConsoleApp1 vanwege zijn beveiligingsniveau niet toegankelijk is in andere assemblages.
5. Intern beschermd
Dit is een combinatie van zowel beveiligde als interne toegangsmodificatoren. Een belangrijk concept om te begrijpen is dat Protected Internal betekent Protected OF Internal. Het is een combinatie van beide toegangsmodificatoren. Men mag nooit denken dat het een kruising is.
Interne objecten zijn dus niet toegankelijk buiten de assembly, terwijl beschermde objecten toegankelijk zijn voor elke afgeleide klasse in een assembly. Wat als ik mijn object alleen in andere merken wil beschermen en niet in dezelfde vergadering? Eenvoudige oplossing - verklaar het intern als beveiligd.
Voorbeeld
Stap 1: Laten we onze ConsoleApp1 aanpassen aan de onderstaande code. Merk op dat we het toegangsniveau van onze variabele 'x' hebben gewijzigd in beveiligde intern.
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);
)
)
)
Stap 2: Bouw de oplossing opnieuw en vervang de .dll in ConsoleApp2 door de bijgewerkte.
Stap 3: Update de code in ConsoleApp2 zoals hieronder:
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();
)
)
)
Stap 4: Voer ConsoleApp2 uit om de uitvoer te zien.
6. Privé beschermd
Dit is een combinatie van zowel privé- als beveiligde toegangsmodificatoren. Beschermd intern betekent Beschermd OF Intern. Privé-objecten zijn dus niet toegankelijk buiten het codeblok waarin het wordt gedeclareerd, terwijl beveiligde objecten toegankelijk zijn voor elke afgeleide klasse in een assembly. Wat als ik de toegang van mijn object wil beperken, zelfs in afgeleide klassen in andere merken? Eenvoudige oplossing - verklaar het intern als beveiligd.
Voorbeeld
Laten we het toegangsniveau van 'x' in ConsoleApp1 wijzigen 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();
)
)
)
Output:
Tabelvergelijking
| Toegangsspecificatie | Zelfde montage | Andere vergadering | |||
| Zelfde klas | Afgeleide klasse | Niet-afgeleide klasse | Afgeleide klasse | Niet-afgeleide klasse | |
| Privaat | Ja | Nee | Nee | Nee | Nee |
| Openbaar | Ja | Ja | Ja | Ja | Ja |
| beschermde | Ja | Ja | Nee | Ja | Nee |
| intern | Ja | Ja | Ja | Nee | Nee |
| Beschermd intern | Ja | Ja | Ja | Ja | Nee |
| Privé beschermd | Ja | Ja | Nee | Nee | Nee |
Conclusie
We hebben in het bovenstaande artikel gezien dat toegangsmodificatoren de toegang tot alles in het project beheren. Verschillende combinaties van toegangsniveaus dekken de behoeften van verschillende soorten toegankelijkheid. De ontwikkelaars moeten verstandig kiezen, rekening houdend met de veiligheid en de absolute noodzaak dat het object toegankelijk is in een bepaald codeblok.
Aanbevolen artikelen
Dit is een gids voor de toegangsmodificaties in C #. Hier hebben we de inleidingstypes van toegangsmodificaties in C # besproken, samen met voorbeelden en uitgangen. U kunt ook onze andere voorgestelde artikelen doornemen voor meer informatie–
- C # Compilers
- Destructor in C #
- Wat is TypeScript?
- Wat is ASP.Net Web Services?
- Toegang tot modificaties in PHP
- Werken en Top 3 Enum-methoden in C #